@jackwener/opencli 1.7.11 → 1.7.12

package/clis/ones/login.js

@@ -4,6 +4,7 @@ import { getOnesBaseUrl, onesFetchInPage } from './common.js';
 cli({
     site: 'ones',
     name: 'login',
+    access: 'write',
     description: 'ONES Project API — login via Chrome Bridge (POST auth/login); stderr prints export hints for ONES_USER_ID / TOKEN',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/logout.js

@@ -3,6 +3,7 @@ import { onesFetchInPage } from './common.js';
 cli({
     site: 'ones',
     name: 'logout',
+    access: 'write',
     description: 'ONES Project API — invalidate current token (GET auth/logout) via Chrome Bridge',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/me.js

@@ -4,6 +4,7 @@ import { onesFetchInPage } from './common.js';
 cli({
     site: 'ones',
     name: 'me',
+    access: 'read',
     description: 'ONES Project API — current user (GET users/me) via Chrome Bridge',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/my-tasks.js

@@ -39,6 +39,7 @@ async function peekTasks(page, team, query, cap) {
 cli({
     site: 'ones',
     name: 'my-tasks',
+    access: 'read',
     description: 'ONES — my work items (filters/peek + strict must query). Default: assignee=me. Use --mode if your site uses field004 for assignee.',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/task.js

@@ -10,6 +10,7 @@ import { formatStamp } from './task-helpers.js';
 cli({
     site: 'ones',
     name: 'task',
+    access: 'read',
     description: 'ONES — work item detail (GET team/:team/task/:id/info); id is URL segment after …/task/',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/tasks.js

@@ -20,6 +20,7 @@ function buildQuery(project, assign) {
 cli({
     site: 'ones',
     name: 'tasks',
+    access: 'read',
     description: 'ONES Project API — list work items (POST team/:team/filters/peek); use token-info -f json for team uuid',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/token-info.js

@@ -4,6 +4,7 @@ import { onesFetchInPage } from './common.js';
 cli({
     site: 'ones',
     name: 'token-info',
+    access: 'read',
     description: 'ONES Project API — session detail (GET auth/token_info) via Chrome Bridge: user, teams, org',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/ones/worklog.js

@@ -99,6 +99,7 @@ export function buildAddManhourGraphqlBody(input) {
 cli({
     site: 'ones',
     name: 'worklog',
+    access: 'write',
     description: 'ONES — log work hours on a task (defaults to today; use --date to backfill; endpoint falls back by deployment).',
     domain: 'ones.cn',
     strategy: Strategy.COOKIE,

package/clis/openreview/openreview.test.js

@@ -0,0 +1,345 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import {
+    absolutePdf,
+    coerceInt,
+    formatDate,
+    noteToRow,
+    requireBoundedInt,
+    requireForumId,
+    requireNonNegativeInt,
+} from './utils.js';
+import './search.js';
+import './venue.js';
+import './paper.js';
+import './reviews.js';
+
+const SAMPLE_NOTE = {
+    id: 'abc123XYZ_',
+    forum: 'abc123XYZ_',
+    pdate: 1727524853394,
+    cdate: 1727524853394,
+    content: {
+        title: { value: 'Test Paper Title with   spaces' },
+        authors: { value: ['Alice Smith', 'Bob Jones'] },
+        authorids: { value: ['~Alice_Smith1', '~Bob_Jones2'] },
+        keywords: { value: ['transformer', 'attention'] },
+        abstract: { value: 'A long abstract\n  with newlines.' },
+        venue: { value: 'ICLR 2024 oral' },
+        venueid: { value: 'ICLR.cc/2024/Conference' },
+        primary_area: { value: 'foundation models' },
+        pdf: { value: '/pdf/abc.pdf' },
+    },
+};
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+});
+
+describe('openreview adapter', () => {
+    it('registers all four commands with the expected columns', () => {
+        const search = getRegistry().get('openreview/search');
+        const venue = getRegistry().get('openreview/venue');
+        const paper = getRegistry().get('openreview/paper');
+        const reviews = getRegistry().get('openreview/reviews');
+
+        expect(search).toBeDefined();
+        expect(venue).toBeDefined();
+        expect(paper).toBeDefined();
+        expect(reviews).toBeDefined();
+
+        expect(search.columns).toEqual(['rank', 'id', 'title', 'authors', 'venue', 'pdate', 'url']);
+        expect(venue.columns).toEqual(['rank', 'id', 'title', 'authors', 'keywords', 'primary_area', 'pdate', 'pdf', 'url']);
+        expect(paper.columns).toEqual(['id', 'title', 'authors', 'keywords', 'venue', 'venueid', 'primary_area', 'abstract', 'pdate', 'pdf', 'url']);
+        expect(reviews.columns).toEqual(['type', 'author', 'rating', 'confidence', 'text']);
+    });
+
+    it('noteToRow extracts every wrapped v2 field, joins lists, and builds absolute URLs', () => {
+        const row = noteToRow(SAMPLE_NOTE);
+        expect(row.id).toBe('abc123XYZ_');
+        expect(row.title).toBe('Test Paper Title with spaces');
+        expect(row.authors).toBe('Alice Smith, Bob Jones');
+        expect(row.keywords).toBe('transformer, attention');
+        expect(row.abstract).toBe('A long abstract with newlines.');
+        expect(row.venue).toBe('ICLR 2024 oral');
+        expect(row.venueid).toBe('ICLR.cc/2024/Conference');
+        expect(row.primary_area).toBe('foundation models');
+        expect(row.pdf).toBe('https://openreview.net/pdf/abc.pdf');
+        expect(row.url).toBe('https://openreview.net/forum?id=abc123XYZ_');
+        expect(row.pdate).toBe('2024-09-28');
+    });
+
+    it('noteToRow falls back to author IDs when authors field is missing', () => {
+        const note = { ...SAMPLE_NOTE, content: { ...SAMPLE_NOTE.content, authors: undefined } };
+        expect(noteToRow(note).authors).toBe('Alice Smith, Bob Jones');
+    });
+
+    it('coerceInt accepts numeric strings, rejects floats and NaN', () => {
+        expect(coerceInt(10)).toBe(10);
+        expect(coerceInt('25')).toBe(25);
+        expect(Number.isNaN(coerceInt(1.5))).toBe(true);
+        expect(Number.isNaN(coerceInt('abc'))).toBe(true);
+        expect(Number.isNaN(coerceInt(undefined))).toBe(true);
+        expect(Number.isNaN(coerceInt(''))).toBe(true);
+    });
+
+    it('requireBoundedInt rejects non-positive, non-integer and over-cap values', () => {
+        expect(requireBoundedInt(10, 25, 50)).toBe(10);
+        expect(requireBoundedInt(undefined, 25, 50)).toBe(25);
+        expect(() => requireBoundedInt(0, 25, 50)).toThrow('positive integer');
+        expect(() => requireBoundedInt(1.5, 25, 50)).toThrow('positive integer');
+        expect(() => requireBoundedInt(51, 25, 50)).toThrow('<= 50');
+        expect(() => requireBoundedInt('abc', 25, 50)).toThrow('positive integer');
+    });
+
+    it('requireNonNegativeInt accepts 0 and rejects negatives', () => {
+        expect(requireNonNegativeInt(0, 0)).toBe(0);
+        expect(requireNonNegativeInt(50, 0)).toBe(50);
+        expect(() => requireNonNegativeInt(-1, 0)).toThrow('non-negative integer');
+        expect(() => requireNonNegativeInt(1.5, 0)).toThrow('non-negative integer');
+    });
+
+    it('requireForumId rejects empty and malformed ids', () => {
+        expect(requireForumId('5sRnsubyAK')).toBe('5sRnsubyAK');
+        expect(requireForumId('abc-def_12')).toBe('abc-def_12');
+        expect(() => requireForumId('')).toThrow('required');
+        expect(() => requireForumId('  ')).toThrow('required');
+        expect(() => requireForumId('has space')).toThrow('not a valid forum id');
+        expect(() => requireForumId('a/b')).toThrow('not a valid forum id');
+        expect(() => requireForumId('short')).toThrow('not a valid forum id');
+    });
+
+    it('formatDate handles ms-since-epoch and rejects invalid input', () => {
+        expect(formatDate(1727524853394)).toBe('2024-09-28');
+        expect(formatDate(0)).toBe('');
+        expect(formatDate(undefined)).toBe('');
+        expect(formatDate('abc')).toBe('');
+    });
+
+    it('absolutePdf prefixes relative paths and preserves absolute URLs', () => {
+        expect(absolutePdf('/pdf/abc.pdf')).toBe('https://openreview.net/pdf/abc.pdf');
+        expect(absolutePdf('http://arxiv.org/pdf/1.pdf')).toBe('http://arxiv.org/pdf/1.pdf');
+        expect(absolutePdf('https://example.com/x.pdf')).toBe('https://example.com/x.pdf');
+        expect(absolutePdf('')).toBe('');
+        expect(absolutePdf(undefined)).toBe('');
+    });
+
+    it('search throws ArgumentError on empty query', async () => {
+        const search = getRegistry().get('openreview/search');
+        await expect(search.func({ query: '', limit: 10 })).rejects.toMatchObject({ code: 'ARGUMENT' });
+        await expect(search.func({ query: '   ', limit: 10 })).rejects.toMatchObject({ code: 'ARGUMENT' });
+    });
+
+    it('search throws EmptyResult when API returns no notes', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({ notes: [] }), { status: 200 })));
+        const search = getRegistry().get('openreview/search');
+        await expect(search.func({ query: 'no-such-paper-xyz', limit: 5 })).rejects.toMatchObject({ code: 'EMPTY_RESULT' });
+    });
+
+    it('search wraps non-200 responses as CommandExecutionError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('rate limited', { status: 429 })));
+        const search = getRegistry().get('openreview/search');
+        await expect(search.func({ query: 'transformer', limit: 5 })).rejects.toMatchObject({ code: 'COMMAND_EXEC' });
+    });
+
+    it('search wraps fetch network errors', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('ECONNRESET')));
+        const search = getRegistry().get('openreview/search');
+        await expect(search.func({ query: 'transformer', limit: 5 })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('Network failure'),
+        });
+    });
+
+    it('search wraps malformed JSON', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('not-json', { status: 200 })));
+        const search = getRegistry().get('openreview/search');
+        await expect(search.func({ query: 'transformer', limit: 5 })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('Malformed JSON'),
+        });
+    });
+
+    it('search wraps OpenReview in-band error envelopes as CommandExecutionError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({
+            errors: [{ message: 'bad term' }],
+        }), { status: 200 })));
+        const search = getRegistry().get('openreview/search');
+        await expect(search.func({ query: 'transformer', limit: 5 })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('bad term'),
+        });
+    });
+
+    it('search returns rank-ordered rows with the expected shape', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({ notes: [SAMPLE_NOTE, SAMPLE_NOTE] }), { status: 200 })));
+        const search = getRegistry().get('openreview/search');
+        const rows = await search.func({ query: 'transformer', limit: 5 });
+        expect(rows).toHaveLength(2);
+        expect(rows[0]).toEqual({
+            rank: 1,
+            id: 'abc123XYZ_',
+            title: 'Test Paper Title with spaces',
+            authors: 'Alice Smith, Bob Jones',
+            venue: 'ICLR 2024 oral',
+            pdate: '2024-09-28',
+            url: 'https://openreview.net/forum?id=abc123XYZ_',
+        });
+        expect(rows[1].rank).toBe(2);
+    });
+
+    it('venue dispatches invitation vs venue-text via /-/ heuristic', async () => {
+        // Each call must return a fresh Response — bodies can only be read once.
+        const fetchMock = vi.fn().mockImplementation(() => Promise.resolve(new Response(JSON.stringify({ notes: [SAMPLE_NOTE] }), { status: 200 })));
+        vi.stubGlobal('fetch', fetchMock);
+        const venue = getRegistry().get('openreview/venue');
+        await venue.func({ venue: 'ICLR.cc/2025/Conference/-/Submission', limit: 1, offset: 0 });
+        expect(fetchMock.mock.calls[0][0]).toContain('invitation=ICLR.cc');
+        await venue.func({ venue: 'ICLR 2024 oral', limit: 1, offset: 0 });
+        expect(fetchMock.mock.calls[1][0]).toContain('content.venue=ICLR%202024%20oral');
+    });
+
+    it('venue applies offset to the rank column so paginated results stay ordered', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({ notes: [SAMPLE_NOTE, SAMPLE_NOTE] }), { status: 200 })));
+        const venue = getRegistry().get('openreview/venue');
+        const rows = await venue.func({ venue: 'ICLR 2024 oral', limit: 2, offset: 50 });
+        expect(rows[0].rank).toBe(51);
+        expect(rows[1].rank).toBe(52);
+    });
+
+    it('paper rejects invalid ids before calling the network', async () => {
+        const paper = getRegistry().get('openreview/paper');
+        await expect(paper.func({ id: '' })).rejects.toMatchObject({ code: 'ARGUMENT' });
+        await expect(paper.func({ id: 'has space' })).rejects.toMatchObject({ code: 'ARGUMENT' });
+    });
+
+    it('paper throws EmptyResult when the note id is unknown', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({ notes: [] }), { status: 200 })));
+        const paper = getRegistry().get('openreview/paper');
+        await expect(paper.func({ id: 'abc123XYZ_' })).rejects.toMatchObject({ code: 'EMPTY_RESULT' });
+    });
+
+    it('paper returns a single row with the full abstract intact', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({ notes: [SAMPLE_NOTE] }), { status: 200 })));
+        const paper = getRegistry().get('openreview/paper');
+        const rows = await paper.func({ id: 'abc123XYZ_' });
+        expect(rows).toHaveLength(1);
+        expect(rows[0].abstract).toBe('A long abstract with newlines.');
+        expect(rows[0].pdf).toBe('https://openreview.net/pdf/abc.pdf');
+    });
+
+    it('reviews rejects max-length below 200', async () => {
+        const reviews = getRegistry().get('openreview/reviews');
+        await expect(reviews.func({ forum: 'abc123XYZ_', 'max-length': 100 })).rejects.toMatchObject({ code: 'ARGUMENT' });
+    });
+
+    it('reviews emits PAPER first then sorts by cdate, classifies invitations, and joins sections', async () => {
+        const replyReview = {
+            id: 'review1aaa',
+            forum: 'abc123XYZ_',
+            replyto: 'abc123XYZ_',
+            cdate: 1727524900000,
+            invitations: ['ICLR.cc/2025/Conference/Submission1/-/Official_Review'],
+            signatures: ['ICLR.cc/2025/Conference/Submission1/Reviewer_uVwr'],
+            content: {
+                summary: { value: 'Short summary' },
+                strengths: { value: 'Solid baselines' },
+                weaknesses: { value: 'Limited novelty' },
+                rating: { value: 5 },
+                confidence: { value: 4 },
+            },
+        };
+        const replyDecision = {
+            id: 'decision01',
+            forum: 'abc123XYZ_',
+            replyto: 'abc123XYZ_',
+            cdate: 1727525000000,
+            invitations: ['ICLR.cc/2025/Conference/-/Decision'],
+            signatures: ['ICLR.cc/2025/Conference/Program_Chairs'],
+            content: {
+                decision: { value: 'Accept (poster)' },
+            },
+        };
+        const replyMetaReview = {
+            id: 'meta000001',
+            forum: 'abc123XYZ_',
+            replyto: 'abc123XYZ_',
+            cdate: 1727524950000,
+            invitations: ['ICLR.cc/2025/Conference/Submission1/-/Meta_Review'],
+            signatures: ['ICLR.cc/2025/Conference/Area_Chair_1'],
+            content: {
+                summary: { value: 'Meta summary' },
+            },
+        };
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(async (url) => {
+            const href = String(url);
+            if (href.includes('/notes?id=')) {
+                return new Response(JSON.stringify({ notes: [SAMPLE_NOTE] }), { status: 200 });
+            }
+            return new Response(JSON.stringify({ notes: [replyDecision, replyReview, { ...SAMPLE_NOTE }, replyMetaReview] }), { status: 200 });
+        }));
+        const reviews = getRegistry().get('openreview/reviews');
+        const rows = await reviews.func({ forum: 'abc123XYZ_', 'max-length': 4000 });
+        expect(rows[0].type).toBe('PAPER');
+        expect(rows.filter((row) => row.type === 'PAPER')).toHaveLength(1);
+        expect(rows[1].type).toBe('REVIEW');
+        expect(rows[1].author).toBe('Reviewer_uVwr');
+        expect(rows[1].rating).toBe('5');
+        expect(rows[1].confidence).toBe('4');
+        expect(rows[1].text).toContain('Summary: Short summary');
+        expect(rows[1].text).toContain('Strengths: Solid baselines');
+        expect(rows[2].type).toBe('META_REVIEW');
+        expect(rows[2].author).toBe('Area_Chair_1');
+        expect(rows[2].text).toContain('Summary: Meta summary');
+        expect(rows[3].type).toBe('DECISION');
+        expect(rows[3].author).toBe('Program_Chairs');
+        expect(rows[3].text).toContain('Decision: Accept (poster)');
+    });
+
+    it('reviews still emits PAPER row 0 when forum replies response omits the root note', async () => {
+        const replyReview = {
+            id: 'review1aaa',
+            forum: 'abc123XYZ_',
+            replyto: 'abc123XYZ_',
+            cdate: 1727524900000,
+            invitations: ['ICLR.cc/2025/Conference/Submission1/-/Official_Review'],
+            signatures: ['ICLR.cc/2025/Conference/Submission1/Reviewer_uVwr'],
+            content: { summary: { value: 'Short summary' } },
+        };
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(async (url) => {
+            const href = String(url);
+            if (href.includes('/notes?id=')) {
+                return new Response(JSON.stringify({ notes: [SAMPLE_NOTE] }), { status: 200 });
+            }
+            return new Response(JSON.stringify({ notes: [replyReview] }), { status: 200 });
+        }));
+        const reviews = getRegistry().get('openreview/reviews');
+        const rows = await reviews.func({ forum: 'abc123XYZ_', 'max-length': 4000 });
+        expect(rows[0].type).toBe('PAPER');
+        expect(rows[0].author).toBe('');
+        expect(rows[1].type).toBe('REVIEW');
+    });
+
+    it('reviews truncates long text to max-length with ellipsis', async () => {
+        const longReview = {
+            id: 'longreview1',
+            forum: 'abc123XYZ_',
+            replyto: 'abc123XYZ_',
+            cdate: 1727524900000,
+            invitations: ['ICLR.cc/2025/Conference/Submission1/-/Official_Review'],
+            signatures: ['ICLR.cc/2025/Conference/Submission1/Reviewer_xxxx'],
+            content: { summary: { value: 'x'.repeat(5000) } },
+        };
+        vi.stubGlobal('fetch', vi.fn().mockImplementation(async (url) => {
+            const href = String(url);
+            if (href.includes('/notes?id=')) {
+                return new Response(JSON.stringify({ notes: [SAMPLE_NOTE] }), { status: 200 });
+            }
+            return new Response(JSON.stringify({ notes: [longReview] }), { status: 200 });
+        }));
+        const reviews = getRegistry().get('openreview/reviews');
+        const rows = await reviews.func({ forum: 'abc123XYZ_', 'max-length': 500 });
+        expect(rows[1].text.length).toBe(500);
+        expect(rows[1].text.endsWith('...')).toBe(true);
+    });
+});

package/clis/openreview/paper.js

@@ -0,0 +1,43 @@
+/**
+ * OpenReview single paper detail (full abstract + metadata).
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { noteToRow, openreviewFetch, requireForumId } from './utils.js';
+
+cli({
+    site: 'openreview',
+    name: 'paper',
+    access: 'read',
+    description: 'Show full metadata for a single OpenReview paper',
+    domain: 'openreview.net',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'OpenReview note id (e.g. "5sRnsubyAK")' },
+    ],
+    columns: ['id', 'title', 'authors', 'keywords', 'venue', 'venueid', 'primary_area', 'abstract', 'pdate', 'pdf', 'url'],
+    func: async (args) => {
+        const id = requireForumId(args.id);
+        const path = `/notes?id=${encodeURIComponent(id)}`;
+        const json = await openreviewFetch(path, `openreview paper ${id}`);
+        const notes = Array.isArray(json?.notes) ? json.notes : [];
+        if (!notes.length) {
+            throw new EmptyResultError('openreview', `No paper found with id "${id}". Confirm the forum/note id from openreview.net.`);
+        }
+        const row = noteToRow(notes[0]);
+        return [{
+            id: row.id,
+            title: row.title,
+            authors: row.authors,
+            keywords: row.keywords,
+            venue: row.venue,
+            venueid: row.venueid,
+            primary_area: row.primary_area,
+            abstract: row.abstract,
+            pdate: row.pdate,
+            pdf: row.pdf,
+            url: row.url,
+        }];
+    },
+});

package/clis/openreview/reviews.js

@@ -0,0 +1,131 @@
+/**
+ * OpenReview paper + threaded reviews/decisions/comments.
+ *
+ * Walks the forum tree once and emits one row per note in chronological order:
+ *   PAPER → REVIEW (one per reviewer) → REBUTTAL/COMMENT → DECISION → WITHDRAWAL.
+ *
+ * Each row carries `rating` / `confidence` so reviewers stand out at a glance.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
+import { coerceInt, openreviewFetch, readContent, requireForumId } from './utils.js';
+
+const SECTION_FIELDS = [
+    ['summary', 'Summary'],
+    ['strengths', 'Strengths'],
+    ['weaknesses', 'Weaknesses'],
+    ['questions', 'Questions'],
+    ['comment', 'Comment'],
+    ['rebuttal', 'Rebuttal'],
+    ['decision', 'Decision'],
+    ['recommendation', 'Recommendation'],
+    ['title', 'Title'],
+    ['abstract', 'Abstract'],
+    ['withdrawal_confirmation', 'Withdrawal confirmation'],
+];
+
+/** Pull the trailing segment of an invitation id (e.g. ".../-/Official_Review" → "Official_Review"). */
+function invitationTail(invitations) {
+    if (!Array.isArray(invitations)) return '';
+    for (const inv of invitations) {
+        const m = String(inv).match(/\/-\/([^/]+)$/);
+        if (m) return m[1];
+    }
+    return '';
+}
+
+/** Map a note's invitation tail to a row type label. */
+function classifyNote(note, isRoot) {
+    if (isRoot) return 'PAPER';
+    const tail = invitationTail(note?.invitations).toLowerCase();
+    if (tail.includes('decision')) return 'DECISION';
+    if (tail.includes('withdrawal')) return 'WITHDRAWAL';
+    if (tail.includes('rebuttal')) return 'REBUTTAL';
+    if (tail.includes('meta')) return 'META_REVIEW';
+    if (tail.includes('review')) return 'REVIEW';
+    if (tail.includes('comment')) return 'COMMENT';
+    return tail ? tail.toUpperCase() : 'NOTE';
+}
+
+/**
+ * Pick the most informative signature segment, e.g.:
+ *   "ICLR.cc/2025/Conference/Submission14296/Reviewer_uVwr" → "Reviewer_uVwr"
+ *   "ICLR.cc/2025/Conference/Program_Chairs"               → "Program_Chairs"
+ *   "~Pedro_Jose_Moreno_Mengibar1"                          → "Pedro Jose Moreno Mengibar"
+ */
+function authorFromSignatures(signatures) {
+    if (!Array.isArray(signatures) || !signatures.length) return '';
+    const sig = String(signatures[0]);
+    if (sig.startsWith('~')) {
+        return sig.replace(/^~/, '').replace(/\d+$/, '').replace(/_/g, ' ').trim();
+    }
+    const parts = sig.split('/');
+    return parts[parts.length - 1] || sig;
+}
+
+function joinSections(content) {
+    const parts = [];
+    for (const [key, label] of SECTION_FIELDS) {
+        const value = readContent(content, key);
+        if (value === undefined || value === null) continue;
+        const text = Array.isArray(value) ? value.join(', ') : String(value);
+        const trimmed = text.replace(/\r\n/g, '\n').trim();
+        if (!trimmed) continue;
+        parts.push(`${label}: ${trimmed}`);
+    }
+    return parts.join('\n\n');
+}
+
+function truncate(text, maxLength) {
+    if (text.length <= maxLength) return text;
+    return `${text.slice(0, maxLength - 3)}...`;
+}
+
+cli({
+    site: 'openreview',
+    name: 'reviews',
+    access: 'read',
+    description: 'Show full review thread (paper + reviews + decisions) for an OpenReview forum',
+    domain: 'openreview.net',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'forum', positional: true, required: true, help: 'OpenReview forum id (same as paper id)' },
+        { name: 'max-length', type: 'int', default: 4000, help: 'Per-row text truncation (min 200)' },
+    ],
+    columns: ['type', 'author', 'rating', 'confidence', 'text'],
+    func: async (args) => {
+        const forum = requireForumId(args.forum, 'forum');
+        const rawMax = args['max-length'] ?? args.maxLength ?? 4000;
+        const maxLength = coerceInt(rawMax);
+        if (!Number.isInteger(maxLength) || maxLength < 200) {
+            throw new ArgumentError('openreview reviews max-length must be an integer >= 200');
+        }
+        const rootJson = await openreviewFetch(`/notes?id=${encodeURIComponent(forum)}`, `openreview paper ${forum}`);
+        const rootNotes = Array.isArray(rootJson?.notes) ? rootJson.notes : [];
+        const root = rootNotes[0];
+        if (!root) {
+            throw new EmptyResultError('openreview', `No forum found with id "${forum}". Confirm the forum id from openreview.net.`);
+        }
+        const repliesJson = await openreviewFetch(`/notes?forum=${encodeURIComponent(forum)}&details=replies&limit=1000`, `openreview reviews ${forum}`);
+        const replies = Array.isArray(repliesJson?.notes) ? repliesJson.notes.filter(note => note?.id !== forum) : [];
+        // Sort by cdate (creation time) so ordering is deterministic regardless of API order.
+        const sorted = [...replies].sort((a, b) => (a?.cdate ?? 0) - (b?.cdate ?? 0));
+        const ordered = [root, ...sorted];
+        return ordered.map((note) => {
+            const isRoot = note?.id === forum;
+            const type = classifyNote(note, isRoot);
+            const author = authorFromSignatures(note?.signatures);
+            const rating = readContent(note?.content, 'rating');
+            const confidence = readContent(note?.content, 'confidence');
+            const text = truncate(joinSections(note?.content), maxLength);
+            return {
+                type,
+                author,
+                rating: rating === undefined || rating === null ? '' : String(rating),
+                confidence: confidence === undefined || confidence === null ? '' : String(confidence),
+                text,
+            };
+        });
+    },
+});

package/clis/openreview/search.js

@@ -0,0 +1,46 @@
+/**
+ * OpenReview full-text search.
+ */
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
+import { noteToRow, openreviewFetch, requireBoundedInt } from './utils.js';
+
+cli({
+    site: 'openreview',
+    name: 'search',
+    access: 'read',
+    description: 'Search OpenReview papers by free-text query',
+    domain: 'openreview.net',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search keyword (e.g. "diffusion model")' },
+        { name: 'limit', type: 'int', default: 25, help: 'Max results (max 50)' },
+    ],
+    columns: ['rank', 'id', 'title', 'authors', 'venue', 'pdate', 'url'],
+    func: async (args) => {
+        const term = String(args.query ?? '').trim();
+        if (!term) {
+            throw new ArgumentError('openreview search query cannot be empty');
+        }
+        const limit = requireBoundedInt(args.limit, 25, 50);
+        const path = `/notes/search?term=${encodeURIComponent(term)}&type=terms&limit=${limit}`;
+        const json = await openreviewFetch(path, 'openreview search');
+        const notes = Array.isArray(json?.notes) ? json.notes : [];
+        if (!notes.length) {
+            throw new EmptyResultError('openreview', `No papers found for "${term}". Try a different keyword.`);
+        }
+        return notes.slice(0, limit).map((note, i) => {
+            const row = noteToRow(note);
+            return {
+                rank: i + 1,
+                id: row.id,
+                title: row.title,
+                authors: row.authors,
+                venue: row.venue,
+                pdate: row.pdate,
+                url: row.url,
+            };
+        });
+    },
+});