publishport-opencli 1.8.4-pp.1

package/clis/dblp/utils.js

@@ -0,0 +1,290 @@
+/**
+ * DBLP adapter utilities.
+ *
+ * dblp serves a public, unauthenticated API:
+ *   - Publication search (JSON):
+ *     `https://dblp.org/search/publ/api?q=<query>&format=json&h=<limit>`
+ *   - Per-record metadata (XML):
+ *     `https://dblp.org/rec/<key>.xml`
+ *
+ * The search response is well-shaped JSON, but the per-record endpoint is
+ * XML. We parse it with conservative regexes (same pattern as the arxiv
+ * adapter) to avoid pulling in an XML lib for this single endpoint.
+ */
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const DBLP_ORIGIN = 'https://dblp.org';
+
+/**
+ * dblp record keys look like `<type>/<venue>/<short>` (e.g.
+ * `conf/nips/VaswaniSPUJGKP17`, `journals/corr/abs-2509-05821`,
+ * `phd/Smith20`). Allow lowercase letter prefixes plus 1+ slash-segments
+ * containing letters / digits / `_` / `.` / `-`.
+ */
+const KEY_PATTERN = /^[a-z]+(?:\/[A-Za-z0-9_.-]+)+$/;
+
+/**
+ * Wraps `fetch` with typed errors. We always set a UA per dblp's
+ * polite-fetch guidance (https://dblp.org/faq/How+to+use+the+dblp+search+API.html).
+ */
+async function dblpFetch(url, label, accept) {
+    let res;
+    try {
+        res = await fetch(url, {
+            headers: {
+                accept,
+                'user-agent': 'opencli-dblp/1.0 (+https://github.com/jackwener/opencli)',
+            },
+        });
+    }
+    catch (err) {
+        throw new CommandExecutionError(`${label} request failed: ${err?.message ?? err}`, 'Check that dblp.org is reachable from this network.');
+    }
+    if (!res.ok) {
+        if (res.status === 429) {
+            throw new CommandExecutionError(`${label} returned HTTP 429 (rate limited)`, 'dblp throttles clients that fetch too aggressively. Wait a few seconds and retry, or lower --limit.');
+        }
+        if (res.status === 404) {
+            throw new EmptyResultError(label, 'dblp returned 404 — the requested record may not exist.');
+        }
+        throw new CommandExecutionError(`${label} returned HTTP ${res.status}`, 'Inspect the response in a browser at the same URL for more context.');
+    }
+    return res;
+}
+
+export async function dblpFetchJson(path, label) {
+    const res = await dblpFetch(`${DBLP_ORIGIN}${path}`, label, 'application/json');
+    let body;
+    try {
+        body = await res.json();
+    }
+    catch (err) {
+        throw new CommandExecutionError(`${label} returned malformed JSON: ${err?.message ?? err}`);
+    }
+    const statusCode = String(body?.result?.status?.['@code'] ?? '').trim();
+    if (!statusCode) {
+        throw new CommandExecutionError(
+            `${label} returned JSON without result.status.@code`,
+            'dblp changed its JSON envelope or returned a partial error payload; inspect the raw response in a browser.',
+        );
+    }
+    if (statusCode !== '200') {
+        const statusText = String(body?.result?.status?.text ?? '').trim();
+        throw new CommandExecutionError(
+            `${label} returned API status ${statusCode}${statusText ? ` (${statusText})` : ''}`,
+            'dblp accepted the HTTP request but reported an API-level failure. Retry later or inspect the same query in a browser.',
+        );
+    }
+    return body;
+}
+
+export async function dblpFetchXml(path, label) {
+    const res = await dblpFetch(`${DBLP_ORIGIN}${path}`, label, 'application/xml');
+    return res.text();
+}
+
+export function coerceInt(value) {
+    if (value === undefined || value === null || value === '') return NaN;
+    const n = typeof value === 'number' ? value : Number(value);
+    return Number.isFinite(n) && Number.isInteger(n) ? n : NaN;
+}
+
+export function requireBoundedInt(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const n = coerceInt(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(`dblp ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`dblp ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export function requireQuery(value, label = 'query') {
+    const q = String(value ?? '').trim();
+    if (!q) {
+        throw new ArgumentError(`dblp ${label} cannot be empty`);
+    }
+    return q;
+}
+
+export function requireRecordKey(value) {
+    const key = String(value ?? '').trim();
+    if (!key) {
+        throw new ArgumentError('dblp paper key is required');
+    }
+    if (!KEY_PATTERN.test(key)) {
+        throw new ArgumentError(`dblp paper key "${value}" is not a valid record key`, 'Expected something like "conf/nips/VaswaniSPUJGKP17" — copy the `key` column from `dblp search`.');
+    }
+    return key;
+}
+
+/** Decode the small set of XML entities dblp emits in record bodies. */
+export function decodeXmlEntities(text) {
+    if (!text) return '';
+    return String(text)
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&apos;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+        .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10)));
+}
+
+/** Strip dblp's per-author homonym suffixes (`Smith 0001`) → `Smith`. */
+function trimAuthorHomonym(name) {
+    return String(name || '').replace(/\s+\d{4,}$/, '').trim();
+}
+
+/**
+ * Normalize the `info.authors.author` field from a dblp search hit. dblp
+ * collapses single authors into one object instead of a 1-element array.
+ */
+export function normalizeAuthors(authorsField) {
+    if (!authorsField) return [];
+    const raw = authorsField?.author;
+    if (!raw) return [];
+    const list = Array.isArray(raw) ? raw : [raw];
+    return list.map((a) => {
+        if (a && typeof a === 'object') return trimAuthorHomonym(a.text || a['#text'] || '');
+        return trimAuthorHomonym(String(a));
+    }).filter(Boolean);
+}
+
+/**
+ * Project a dblp publication search hit into one row. Drops only the most
+ * volatile fields (e.g. abstract, which dblp does not expose) and keeps
+ * the canonical key as the round-trip handle.
+ */
+export function searchHitToRow(hit, rank) {
+    const info = hit?.info ?? {};
+    const authors = normalizeAuthors(info.authors);
+    const key = String(info.key ?? '').trim();
+    return {
+        rank,
+        key,
+        title: stripTrailingDot(decodeXmlEntities(info.title ?? '')).trim(),
+        authors: authors.join(', '),
+        venue: decodeXmlEntities(info.venue ?? ''),
+        year: String(info.year ?? '').trim(),
+        type: simplifyHitType(info.type),
+        doi: String(info.doi ?? '').trim(),
+        url: String(info.ee ?? info.url ?? '').trim(),
+    };
+}
+
+/** Title strings from dblp end with a period — strip it for cleaner display. */
+function stripTrailingDot(s) {
+    return String(s || '').replace(/\.\s*$/, '');
+}
+
+/** Compress dblp's verbose `type` strings into single-token tags. */
+function simplifyHitType(type) {
+    if (!type) return '';
+    const t = String(type);
+    if (/Conference and Workshop/i.test(t)) return 'conf';
+    if (/Journal Articles/i.test(t)) return 'journal';
+    if (/Books and Theses/i.test(t)) return 'book';
+    if (/Editorship/i.test(t)) return 'editorship';
+    if (/Reference Works/i.test(t)) return 'reference';
+    if (/Informal/i.test(t)) return 'preprint';
+    return t.toLowerCase().split(/\s+/)[0];
+}
+
+/**
+ * Extract a single tag from a dblp record XML blob (regex-based, same
+ * approach as arxiv/utils.js — keeps the dependency surface flat).
+ */
+export function extractFirst(xml, tag) {
+    const m = String(xml || '').match(new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`));
+    return m ? m[1] : '';
+}
+
+export function extractAll(xml, tag) {
+    const out = [];
+    const re = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'g');
+    let m;
+    while ((m = re.exec(String(xml || ''))) !== null) out.push(m[1]);
+    return out;
+}
+
+/**
+ * Pick the first `<ee type="oa">` (open-access link) if present, otherwise
+ * fall back to the first `<ee>`.
+ */
+export function extractOpenAccessLink(xml) {
+    const oa = String(xml || '').match(/<ee\b[^>]*type=["']oa["'][^>]*>([\s\S]*?)<\/ee>/);
+    if (oa) return oa[1].trim();
+    const any = String(xml || '').match(/<ee\b[^>]*>([\s\S]*?)<\/ee>/);
+    return any ? any[1].trim() : '';
+}
+
+/** Pull the `key` attribute off the wrapper element regardless of record type. */
+export function extractRecordKey(xml) {
+    const m = String(xml || '').match(/<(?:article|inproceedings|incollection|proceedings|book|phdthesis|mastersthesis)\b[^>]*\bkey="([^"]+)"/);
+    return m ? m[1] : '';
+}
+
+/**
+ * Identify the record type from the wrapper element name. Maps to the
+ * same simplified tag set the search rows use.
+ */
+export function extractRecordType(xml) {
+    const m = String(xml || '').match(/<(article|inproceedings|incollection|proceedings|book|phdthesis|mastersthesis)\b/);
+    if (!m) return '';
+    switch (m[1]) {
+        case 'inproceedings': return 'conf';
+        case 'article': return 'journal';
+        case 'incollection': return 'incollection';
+        case 'proceedings': return 'editorship';
+        case 'book': return 'book';
+        case 'phdthesis': return 'phdthesis';
+        case 'mastersthesis': return 'mastersthesis';
+        default: return m[1];
+    }
+}
+
+/**
+ * Parse a single dblp record XML into the row shape used by `dblp paper`.
+ * Treats every field as optional; throws upstream when the record body
+ * is missing entirely (404 already handled at fetch level).
+ */
+export function recordXmlToRow(xml) {
+    const key = extractRecordKey(xml);
+    const type = extractRecordType(xml);
+    const title = stripTrailingDot(decodeXmlEntities(extractFirst(xml, 'title')));
+    const authors = extractAll(xml, 'author').map((a) => trimAuthorHomonym(decodeXmlEntities(a)));
+    const year = decodeXmlEntities(extractFirst(xml, 'year'));
+    const pages = decodeXmlEntities(extractFirst(xml, 'pages'));
+    const venueRaw = type === 'conf'
+        ? decodeXmlEntities(extractFirst(xml, 'booktitle'))
+        : decodeXmlEntities(extractFirst(xml, 'journal'));
+    const doi = (() => {
+        const m = String(xml || '').match(/<ee\b[^>]*>([^<]*?(?:doi\.org\/|10\.[^"<]+))<\/ee>/i);
+        if (!m) return '';
+        const v = m[1].replace(/^https?:\/\/(?:dx\.)?doi\.org\//i, '');
+        return v.startsWith('10.') ? v : '';
+    })();
+    return {
+        key,
+        type,
+        title,
+        authors: authors.join(', '),
+        venue: venueRaw,
+        year,
+        pages,
+        doi,
+        open_access_url: extractOpenAccessLink(xml),
+        dblp_url: key ? `${DBLP_ORIGIN}/rec/${key}.html` : '',
+    };
+}
+
+export const SEARCH_COLUMNS = [
+    'rank', 'key', 'title', 'authors', 'venue', 'year', 'type', 'doi', 'url',
+];
+
+export const PAPER_COLUMNS = [
+    'key', 'type', 'title', 'authors', 'venue', 'year', 'pages', 'doi', 'open_access_url', 'dblp_url',
+];

package/clis/dblp/venue.js

@@ -0,0 +1,64 @@
+// dblp venue — search dblp's venue (conference / journal) registry.
+//
+// Hits `https://dblp.org/search/venue/api?q=…&format=json&h=…`. Returns a
+// row per matched venue. Useful for resolving an acronym (e.g. "ICLR" →
+// dblp's canonical venue page) and for browsing venues that match a topic.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    DBLP_ORIGIN,
+    decodeXmlEntities,
+    dblpFetchJson,
+    requireBoundedInt,
+    requireQuery,
+} from './utils.js';
+
+function simplifyVenueType(type) {
+    const t = String(type ?? '').trim();
+    if (!t) return '';
+    if (/Conference or Workshop/i.test(t)) return 'conf';
+    if (/Journal/i.test(t)) return 'journal';
+    if (/Series/i.test(t)) return 'series';
+    if (/Book/i.test(t)) return 'book';
+    if (/Reference/i.test(t)) return 'reference';
+    return t.toLowerCase().split(/\s+/)[0];
+}
+
+function venueHitToRow(hit, rank) {
+    const info = hit?.info ?? {};
+    const url = String(info.url ?? '').trim();
+    return {
+        rank,
+        acronym: String(info.acronym ?? '').trim(),
+        venue: decodeXmlEntities(info.venue ?? ''),
+        type: simplifyVenueType(info.type),
+        url: url.startsWith('http') ? url : url ? `${DBLP_ORIGIN}${url.startsWith('/') ? '' : '/'}${url}` : '',
+    };
+}
+
+cli({
+    site: 'dblp',
+    name: 'venue',
+    access: 'read',
+    description: 'Search dblp venue registry (conferences / journals) by name or acronym',
+    domain: 'dblp.org',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Venue name or acronym (e.g. "ICLR", "neural networks")' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max venues (1-100, single dblp page)' },
+    ],
+    columns: ['rank', 'acronym', 'venue', 'type', 'url'],
+    func: async (args) => {
+        const query = requireQuery(args.query);
+        const limit = requireBoundedInt(args.limit, 20, 100);
+        const path = `/search/venue/api?q=${encodeURIComponent(query)}&format=json&h=${limit}`;
+        const json = await dblpFetchJson(path, 'dblp venue');
+        const hits = json?.result?.hits?.hit;
+        const list = Array.isArray(hits) ? hits : [];
+        if (list.length === 0) {
+            throw new EmptyResultError('dblp venue', `No dblp venues matched "${query}".`);
+        }
+        return list.slice(0, limit).map((hit, i) => venueHitToRow(hit, i + 1));
+    },
+});

package/clis/deepseek/ask.js

@@ -0,0 +1,158 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CliError, CommandExecutionError, EXIT_CODES, TimeoutError } from '@jackwener/opencli/errors';
+import {
+    DEEPSEEK_DOMAIN, DEEPSEEK_URL, ensureOnDeepSeek, selectModel, setFeature,
+    sendMessage, sendWithFile, getBubbleCount, waitForResponse, parseBoolFlag, withRetry,
+    pickResumeUrl, TEXTAREA_SELECTOR,
+} from './utils.js';
+
+export const askCommand = cli({
+    site: 'deepseek',
+    name: 'ask',
+    access: 'write',
+    description: 'Send a prompt to DeepSeek and get the response',
+    domain: DEEPSEEK_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    siteSession: 'persistent',
+    navigateBefore: false,
+    args: [
+        { name: 'prompt', positional: true, required: true, help: 'Prompt to send' },
+        { name: 'timeout', type: 'int', default: 120, help: 'Max seconds to wait for response' },
+        { name: 'new', type: 'boolean', default: false, help: 'Start a new chat before sending' },
+        { name: 'model', default: 'instant', choices: ['instant', 'expert', 'vision'], help: 'Model to use: instant, expert, or vision' },
+        { name: 'think', type: 'boolean', default: false, help: 'Enable DeepThink mode' },
+        { name: 'search', type: 'boolean', default: false, help: 'Enable web search' },
+        { name: 'file', help: 'Attach a file (PDF, image, text) with the prompt' },
+    ],
+    // columns omitted: derived from row keys so non-think output shows only 'response'
+
+    func: async (page, kwargs) => {
+        const prompt = kwargs.prompt;
+        const timeoutMs = (kwargs.timeout || 120) * 1000;
+        const wantThink = parseBoolFlag(kwargs.think);
+        const wantSearch = parseBoolFlag(kwargs.search);
+        const wantModel = kwargs.model || 'instant';
+
+        if ((wantModel === 'vision' || wantModel === 'expert') && wantSearch) {
+            throw new CliError(
+                'ARGUMENT',
+                `DeepSeek ${wantModel} mode does not support --search.`,
+                'Run without --search, or use --model instant for web search.',
+                EXIT_CODES.USAGE_ERROR,
+            );
+        }
+
+        if (parseBoolFlag(kwargs.new)) {
+            await page.goto(DEEPSEEK_URL);
+            // Wait for the composer to mount instead of a fixed 3 s sleep.
+            try {
+                await page.wait({ selector: TEXTAREA_SELECTOR, timeout: 8 });
+            } catch {
+                // Selector still missing → downstream selectModel/sendMessage
+                // will surface the failure with a typed error.
+            }
+        } else {
+            const navigated = await ensureOnDeepSeek(page);
+            if (navigated) {
+                // Pinned conversations sit in their own DOM section and are
+                // skipped so the resume never lands on a topped chat.
+                const resumeUrl = await pickResumeUrl(page);
+                if (!resumeUrl) {
+                    throw new CommandExecutionError(
+                        'Workspace was recycled but no prior conversation could be loaded',
+                        'Pass --new to start a fresh chat, or wait for the sidebar to populate before retrying.',
+                    );
+                }
+                await page.goto(resumeUrl);
+                try {
+                    await page.wait({ selector: TEXTAREA_SELECTOR, timeout: 5 });
+                } catch {
+                    // Conversation page may still be loading; subsequent steps
+                    // will retry or report.
+                }
+            }
+        }
+
+        // Model selector is only available on the new-chat page, not inside
+        // an existing conversation. Skip it when we resumed a prior thread.
+        const currentUrl = await page.evaluate('window.location.href') || '';
+        const inConversation = currentUrl.includes('/a/chat/s/');
+        const modelExplicit = kwargs.__opencliOptionSources?.model === 'cli';
+
+        if (inConversation && modelExplicit) {
+            throw new CliError(
+                'ARGUMENT',
+                `Cannot switch to ${wantModel} model inside an existing conversation.`,
+                'Re-run with --new to start a fresh chat before selecting a model.',
+                EXIT_CODES.USAGE_ERROR,
+            );
+        }
+
+        if (!inConversation) {
+            const modelResult = await withRetry(() => selectModel(page, wantModel));
+            if (!modelResult?.ok) {
+                throw new CommandExecutionError(`Could not switch to ${wantModel} model`);
+            }
+            // The 0.5 s settle previously here was redundant: each subsequent
+            // step (setFeature, sendMessage) issues a fresh CDP eval, giving
+            // React more than enough time to flush the toggle's state update.
+        }
+
+        const thinkResult = await withRetry(() => setFeature(page, 'DeepThink', wantThink));
+        if (!thinkResult?.ok && wantThink) {
+            throw new CommandExecutionError('Could not enable DeepThink');
+        }
+
+        // Only instant mode has the Search toggle in the DeepSeek UI.
+        let searchResult;
+        if (wantModel !== 'vision' && wantModel !== 'expert') {
+            searchResult = await withRetry(() => setFeature(page, 'Search', wantSearch));
+            if (!searchResult?.ok && wantSearch) {
+                throw new CommandExecutionError('Could not enable Search');
+            }
+        }
+
+        // No settle wait after toggles: the next CDP eval below already gives
+        // React time to flush the aria-checked state.
+
+        if (kwargs.file) {
+            const baseline = await withRetry(() => getBubbleCount(page));
+            try {
+                const fileResult = await sendWithFile(page, kwargs.file, prompt);
+                if (fileResult && !fileResult.ok) {
+                    throw new CommandExecutionError(fileResult.reason || 'Failed to attach file');
+                }
+            } catch (err) {
+                // SPA navigates after send; "Promise was collected" means send succeeded
+                if (!String(err?.message || err).includes('Promise was collected')) throw err;
+            }
+            // waitForResponse polls every 3 s for new bubbles, so the previous
+            // 3 s settle here was a redundant sleep on top of the first poll.
+            const result = await waitForResponse(page, baseline, prompt, timeoutMs, wantThink);
+            if (!result) {
+                throw new TimeoutError('deepseek ask', kwargs.timeout, 'No DeepSeek reply observed before timeout. Retry with --timeout increased.');
+            }
+            if (wantThink && typeof result === 'object' && result.response !== undefined) {
+                return [result];
+            }
+            return [{ response: result }];
+        }
+
+        const baseline = await withRetry(() => getBubbleCount(page));
+        const sendResult = await withRetry(() => sendMessage(page, prompt));
+        if (!sendResult?.ok) {
+            throw new CommandExecutionError(sendResult?.reason || 'Failed to send message');
+        }
+
+        const result = await waitForResponse(page, baseline, prompt, timeoutMs, wantThink);
+        if (!result) {
+            throw new TimeoutError('deepseek ask', kwargs.timeout, 'No DeepSeek reply observed before timeout. Retry with --timeout increased.');
+        }
+
+        if (wantThink && typeof result === 'object' && result.response !== undefined) {
+            return [result];
+        }
+        return [{ response: result }];
+    },
+});