@jackwener/opencli 1.6.2 → 1.6.3

package/src/clis/paperreview/commands.test.ts

@@ -1,283 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-const {
-  mockReadPdfFile,
-  mockRequestJson,
-  mockUploadPresignedPdf,
-  mockValidateHelpfulness,
-  mockParseYesNo,
-} = vi.hoisted(() => ({
-  mockReadPdfFile: vi.fn(),
-  mockRequestJson: vi.fn(),
-  mockUploadPresignedPdf: vi.fn(),
-  mockValidateHelpfulness: vi.fn(),
-  mockParseYesNo: vi.fn(),
-}));
-
-vi.mock('./utils.js', async () => {
-  const actual = await vi.importActual<typeof import('./utils.js')>('./utils.js');
-  return {
-    ...actual,
-    readPdfFile: mockReadPdfFile,
-    requestJson: mockRequestJson,
-    uploadPresignedPdf: mockUploadPresignedPdf,
-    validateHelpfulness: mockValidateHelpfulness,
-    parseYesNo: mockParseYesNo,
-  };
-});
-
-import { getRegistry } from '../../registry.js';
-import './submit.js';
-import './review.js';
-import './feedback.js';
-
-describe('paperreview submit command', () => {
-  beforeEach(() => {
-    mockReadPdfFile.mockReset();
-    mockRequestJson.mockReset();
-    mockUploadPresignedPdf.mockReset();
-    mockValidateHelpfulness.mockReset();
-    mockParseYesNo.mockReset();
-  });
-
-  it('supports dry run without any remote request', async () => {
-    const cmd = getRegistry().get('paperreview/submit');
-    expect(cmd?.func).toBeTypeOf('function');
-
-    mockReadPdfFile.mockResolvedValue({
-      buffer: Buffer.from('%PDF'),
-      fileName: 'paper.pdf',
-      resolvedPath: '/tmp/paper.pdf',
-      sizeBytes: 4096,
-    });
-
-    const result = await cmd!.func!(null as any, {
-      pdf: './paper.pdf',
-      email: 'wang2629651228@gmail.com',
-      venue: 'RAL',
-      'dry-run': true,
-      'prepare-only': false,
-    });
-
-    expect(mockRequestJson).not.toHaveBeenCalled();
-    expect(result).toMatchObject({
-      status: 'dry-run',
-      file: 'paper.pdf',
-      email: 'wang2629651228@gmail.com',
-      venue: 'RAL',
-    });
-  });
-
-  it('treats explicit false flags as false and performs the real submission path', async () => {
-    const cmd = getRegistry().get('paperreview/submit');
-    expect(cmd?.func).toBeTypeOf('function');
-
-    mockReadPdfFile.mockResolvedValue({
-      buffer: Buffer.from('%PDF'),
-      fileName: 'paper.pdf',
-      resolvedPath: '/tmp/paper.pdf',
-      sizeBytes: 4096,
-    });
-    mockRequestJson
-      .mockResolvedValueOnce({
-        response: { ok: true, status: 200 } as Response,
-        payload: {
-          success: true,
-          presigned_url: 'https://upload.example.com',
-          presigned_fields: { key: 'uploads/paper.pdf' },
-          s3_key: 'uploads/paper.pdf',
-        },
-      })
-      .mockResolvedValueOnce({
-        response: { ok: true, status: 200 } as Response,
-        payload: {
-          success: true,
-          token: 'tok_false',
-          message: 'Submission accepted',
-        },
-      });
-
-    const result = await cmd!.func!(null as any, {
-      pdf: './paper.pdf',
-      email: 'wang2629651228@gmail.com',
-      venue: 'RAL',
-      'dry-run': false,
-      'prepare-only': false,
-    });
-
-    expect(mockUploadPresignedPdf).toHaveBeenCalledTimes(1);
-    expect(result).toMatchObject({
-      status: 'submitted',
-      token: 'tok_false',
-      review_url: 'https://paperreview.ai/review?token=tok_false',
-    });
-  });
-
-  it('supports prepare-only without uploading the PDF', async () => {
-    const cmd = getRegistry().get('paperreview/submit');
-    expect(cmd?.func).toBeTypeOf('function');
-
-    mockReadPdfFile.mockResolvedValue({
-      buffer: Buffer.from('%PDF'),
-      fileName: 'paper.pdf',
-      resolvedPath: '/tmp/paper.pdf',
-      sizeBytes: 4096,
-    });
-    mockRequestJson.mockResolvedValueOnce({
-      response: { ok: true, status: 200 } as Response,
-      payload: {
-        success: true,
-        presigned_url: 'https://upload.example.com',
-        presigned_fields: { key: 'uploads/paper.pdf' },
-        s3_key: 'uploads/paper.pdf',
-      },
-    });
-
-    const result = await cmd!.func!(null as any, {
-      pdf: './paper.pdf',
-      email: 'wang2629651228@gmail.com',
-      venue: 'RAL',
-      'dry-run': false,
-      'prepare-only': true,
-    });
-
-    expect(mockUploadPresignedPdf).not.toHaveBeenCalled();
-    expect(mockRequestJson).toHaveBeenCalledTimes(1);
-    expect(result).toMatchObject({
-      status: 'prepared',
-      s3_key: 'uploads/paper.pdf',
-    });
-  });
-
-  it('requests an upload URL, uploads the PDF, and confirms the submission', async () => {
-    const cmd = getRegistry().get('paperreview/submit');
-    expect(cmd?.func).toBeTypeOf('function');
-
-    mockReadPdfFile.mockResolvedValue({
-      buffer: Buffer.from('%PDF'),
-      fileName: 'paper.pdf',
-      resolvedPath: '/tmp/paper.pdf',
-      sizeBytes: 4096,
-    });
-    mockRequestJson
-      .mockResolvedValueOnce({
-        response: { ok: true, status: 200 } as Response,
-        payload: {
-          success: true,
-          presigned_url: 'https://upload.example.com',
-          presigned_fields: { key: 'uploads/paper.pdf' },
-          s3_key: 'uploads/paper.pdf',
-        },
-      })
-      .mockResolvedValueOnce({
-        response: { ok: true, status: 200 } as Response,
-        payload: {
-          success: true,
-          token: 'tok_123',
-          message: 'Submission accepted',
-        },
-      });
-
-    const result = await cmd!.func!(null as any, {
-      pdf: './paper.pdf',
-      email: 'wang2629651228@gmail.com',
-      venue: 'RAL',
-      'dry-run': false,
-      'prepare-only': false,
-    });
-
-    expect(mockRequestJson).toHaveBeenNthCalledWith(1, '/api/get-upload-url', expect.objectContaining({
-      method: 'POST',
-      body: JSON.stringify({
-        filename: 'paper.pdf',
-        venue: 'RAL',
-      }),
-    }));
-    expect(mockUploadPresignedPdf).toHaveBeenCalledWith(
-      'https://upload.example.com',
-      expect.objectContaining({ fileName: 'paper.pdf' }),
-      expect.objectContaining({ s3_key: 'uploads/paper.pdf' }),
-    );
-    expect(mockRequestJson).toHaveBeenNthCalledWith(2, '/api/confirm-upload', expect.objectContaining({
-      method: 'POST',
-      body: expect.any(FormData),
-    }));
-    expect(result).toMatchObject({
-      status: 'submitted',
-      token: 'tok_123',
-      review_url: 'https://paperreview.ai/review?token=tok_123',
-    });
-  });
-});
-
-describe('paperreview review command', () => {
-  beforeEach(() => {
-    mockRequestJson.mockReset();
-  });
-
-  it('returns processing status when the review is not ready yet', async () => {
-    const cmd = getRegistry().get('paperreview/review');
-    expect(cmd?.func).toBeTypeOf('function');
-
-    mockRequestJson.mockResolvedValue({
-      response: { status: 202 } as Response,
-      payload: { detail: 'Review is still processing.' },
-    });
-
-    const result = await cmd!.func!(null as any, { token: 'tok_123' });
-
-    expect(result).toMatchObject({
-      status: 'processing',
-      token: 'tok_123',
-      review_url: 'https://paperreview.ai/review?token=tok_123',
-      message: 'Review is still processing.',
-    });
-  });
-});
-
-describe('paperreview feedback command', () => {
-  beforeEach(() => {
-    mockRequestJson.mockReset();
-    mockValidateHelpfulness.mockReset();
-    mockParseYesNo.mockReset();
-  });
-
-  it('normalizes feedback inputs and posts them to the API', async () => {
-    const cmd = getRegistry().get('paperreview/feedback');
-    expect(cmd?.func).toBeTypeOf('function');
-
-    mockValidateHelpfulness.mockReturnValue(4);
-    mockParseYesNo.mockReturnValueOnce(true).mockReturnValueOnce(false);
-    mockRequestJson.mockResolvedValue({
-      response: { ok: true, status: 200 } as Response,
-      payload: { message: 'Thanks for the feedback.' },
-    });
-
-    const result = await cmd!.func!(null as any, {
-      token: 'tok_123',
-      helpfulness: 4,
-      'critical-error': 'yes',
-      'actionable-suggestions': 'no',
-      'additional-comments': 'Helpful summary, but the contribution section needs more detail.',
-    });
-
-    expect(mockRequestJson).toHaveBeenCalledWith('/api/feedback/tok_123', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        helpfulness: 4,
-        has_critical_error: true,
-        has_actionable_suggestions: false,
-        additional_comments: 'Helpful summary, but the contribution section needs more detail.',
-      }),
-    });
-    expect(result).toMatchObject({
-      status: 'submitted',
-      token: 'tok_123',
-      helpfulness: 4,
-      critical_error: true,
-      actionable_suggestions: false,
-      message: 'Thanks for the feedback.',
-    });
-  });
-});

package/src/clis/paperreview/feedback.ts

@@ -1,64 +0,0 @@
-import { cli, Strategy } from '../../registry.js';
-import { CliError } from '../../errors.js';
-import {
-  PAPERREVIEW_DOMAIN,
-  ensureSuccess,
-  parseYesNo,
-  requestJson,
-  summarizeFeedback,
-  validateHelpfulness,
-} from './utils.js';
-
-cli({
-  site: 'paperreview',
-  name: 'feedback',
-  description: 'Submit feedback for a paperreview.ai review token',
-  domain: PAPERREVIEW_DOMAIN,
-  strategy: Strategy.PUBLIC,
-  browser: false,
-  timeoutSeconds: 30,
-  args: [
-    { name: 'token', positional: true, required: true, help: 'Review token returned by paperreview.ai' },
-    { name: 'helpfulness', required: true, type: 'int', help: 'Helpfulness score from 1 to 5' },
-    { name: 'critical-error', required: true, choices: ['yes', 'no'], help: 'Whether the review contains a critical error' },
-    { name: 'actionable-suggestions', required: true, choices: ['yes', 'no'], help: 'Whether the review contains actionable suggestions' },
-    { name: 'additional-comments', help: 'Optional free-text feedback' },
-  ],
-  columns: ['status', 'token', 'helpfulness', 'critical_error', 'actionable_suggestions', 'message'],
-  func: async (_page, kwargs) => {
-    const token = String(kwargs.token ?? '').trim();
-    if (!token) {
-      throw new CliError('ARGUMENT', 'A review token is required.');
-    }
-
-    const helpfulness = validateHelpfulness(kwargs.helpfulness);
-    const criticalError = parseYesNo(kwargs['critical-error'], 'critical-error');
-    const actionableSuggestions = parseYesNo(kwargs['actionable-suggestions'], 'actionable-suggestions');
-    const comments = String(kwargs['additional-comments'] ?? '').trim();
-
-    const payload: Record<string, unknown> = {
-      helpfulness,
-      has_critical_error: criticalError,
-      has_actionable_suggestions: actionableSuggestions,
-    };
-    if (comments) {
-      payload.additional_comments = comments;
-    }
-
-    const { response, payload: responsePayload } = await requestJson(`/api/feedback/${encodeURIComponent(token)}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(payload),
-    });
-    ensureSuccess(response, responsePayload, 'Failed to submit feedback.', 'Check the token and try again');
-
-    return summarizeFeedback({
-      token,
-      helpfulness,
-      criticalError,
-      actionableSuggestions,
-      comments,
-      payload: responsePayload,
-    });
-  },
-});

package/src/clis/paperreview/review.ts

@@ -1,47 +0,0 @@
-import { cli, Strategy } from '../../registry.js';
-import { CliError } from '../../errors.js';
-import {
-  PAPERREVIEW_DOMAIN,
-  buildReviewUrl,
-  ensureSuccess,
-  requestJson,
-  summarizeReview,
-} from './utils.js';
-
-cli({
-  site: 'paperreview',
-  name: 'review',
-  description: 'Fetch a paperreview.ai review by token',
-  domain: PAPERREVIEW_DOMAIN,
-  strategy: Strategy.PUBLIC,
-  browser: false,
-  timeoutSeconds: 30,
-  args: [
-    { name: 'token', positional: true, required: true, help: 'Review token returned by paperreview.ai' },
-  ],
-  columns: ['status', 'title', 'venue', 'numerical_score', 'has_feedback', 'review_url'],
-  func: async (_page, kwargs) => {
-    const token = String(kwargs.token ?? '').trim();
-    if (!token) {
-      throw new CliError('ARGUMENT', 'A review token is required.');
-    }
-
-    const { response, payload } = await requestJson(`/api/review/${encodeURIComponent(token)}`);
-
-    if (response.status === 202) {
-      return {
-        status: 'processing',
-        token,
-        review_url: buildReviewUrl(token),
-        title: '',
-        venue: '',
-        numerical_score: '',
-        has_feedback: '',
-        message: typeof payload === 'object' && payload ? payload.detail ?? 'Review is still processing.' : 'Review is still processing.',
-      };
-    }
-
-    ensureSuccess(response, payload, 'Failed to fetch the review.', 'Check the token and try again');
-    return summarizeReview(token, payload);
-  },
-});

package/src/clis/paperreview/submit.ts

@@ -1,119 +0,0 @@
-import { cli, Strategy } from '../../registry.js';
-import { CliError } from '../../errors.js';
-import {
-  PAPERREVIEW_DOMAIN,
-  ensureApiSuccess,
-  ensureSuccess,
-  normalizeVenue,
-  readPdfFile,
-  requestJson,
-  summarizeSubmission,
-  uploadPresignedPdf,
-} from './utils.js';
-
-cli({
-  site: 'paperreview',
-  name: 'submit',
-  description: 'Submit a PDF to paperreview.ai for review',
-  domain: PAPERREVIEW_DOMAIN,
-  strategy: Strategy.PUBLIC,
-  browser: false,
-  timeoutSeconds: 120,
-  args: [
-    { name: 'pdf', positional: true, required: true, help: 'Path to the paper PDF' },
-    { name: 'email', required: true, help: 'Email address for the submission' },
-    { name: 'venue', help: 'Optional target venue such as ICLR or NeurIPS' },
-    { name: 'dry-run', type: 'bool', default: false, help: 'Validate the input and stop before remote submission' },
-    { name: 'prepare-only', type: 'bool', default: false, help: 'Request an upload slot but stop before uploading the PDF' },
-  ],
-  columns: ['status', 'file', 'email', 'venue', 'token', 'review_url', 'message'],
-  footerExtra: (kwargs) => {
-    if (kwargs['dry-run'] === true) return 'dry run only';
-    if (kwargs['prepare-only'] === true) return 'prepared only';
-    return undefined;
-  },
-  func: async (_page, kwargs) => {
-    const pdfFile = await readPdfFile(kwargs.pdf);
-    const email = String(kwargs.email ?? '').trim();
-    const venue = normalizeVenue(kwargs.venue);
-    const dryRun = kwargs['dry-run'] === true;
-    const prepareOnly = kwargs['prepare-only'] === true;
-
-    if (!email) {
-      throw new CliError('ARGUMENT', 'An email address is required.', 'Pass --email <address>');
-    }
-
-    if (dryRun) {
-      return summarizeSubmission({
-        pdfFile,
-        email,
-        venue,
-        message: 'Input validation passed. No remote request was sent.',
-        dryRun: true,
-      });
-    }
-
-    const { response: uploadUrlResponse, payload: uploadUrlPayload } = await requestJson('/api/get-upload-url', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        filename: pdfFile.fileName,
-        venue,
-      }),
-    });
-    ensureSuccess(
-      uploadUrlResponse,
-      uploadUrlPayload,
-      'Failed to request an upload URL.',
-      'Try again in a moment',
-    );
-    ensureApiSuccess(
-      uploadUrlPayload,
-      'paperreview.ai did not return a usable upload URL.',
-      'Try again in a moment',
-    );
-
-    if (prepareOnly) {
-      return summarizeSubmission({
-        pdfFile,
-        email,
-        venue,
-        message: 'Upload slot prepared. The PDF was not uploaded and no submission was confirmed.',
-        s3Key: uploadUrlPayload.s3_key,
-        status: 'prepared',
-      });
-    }
-
-    await uploadPresignedPdf(uploadUrlPayload.presigned_url, pdfFile, uploadUrlPayload);
-
-    const confirmForm = new FormData();
-    confirmForm.append('s3_key', uploadUrlPayload.s3_key);
-    confirmForm.append('venue', venue);
-    confirmForm.append('email', email);
-
-    const { response: confirmResponse, payload: confirmPayload } = await requestJson('/api/confirm-upload', {
-      method: 'POST',
-      body: confirmForm,
-    });
-    ensureSuccess(
-      confirmResponse,
-      confirmPayload,
-      'Failed to confirm the upload with paperreview.ai.',
-      'Try again in a moment',
-    );
-    ensureApiSuccess(
-      confirmPayload,
-      'paperreview.ai did not confirm the submission.',
-      'Try again in a moment',
-    );
-
-    return summarizeSubmission({
-      pdfFile,
-      email,
-      venue,
-      token: confirmPayload.token,
-      message: confirmPayload.message,
-      s3Key: uploadUrlPayload.s3_key,
-    });
-  },
-});

package/src/clis/paperreview/utils.test.ts

@@ -1,68 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { CliError } from '../../errors.js';
-import {
-  MAX_PDF_BYTES,
-  buildReviewUrl,
-  parseYesNo,
-  readPdfFile,
-  requestJson,
-  validateHelpfulness,
-} from './utils.js';
-
-describe('paperreview utils', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('builds review URLs from the token', () => {
-    expect(buildReviewUrl('tok 123')).toBe('https://paperreview.ai/review?token=tok%20123');
-  });
-
-  it('parses yes/no flags', () => {
-    expect(parseYesNo('yes', 'critical-error')).toBe(true);
-    expect(parseYesNo('NO', 'critical-error')).toBe(false);
-  });
-
-  it('rejects invalid yes/no flags with CliError', () => {
-    expect(() => parseYesNo('maybe', 'critical-error')).toThrow(CliError);
-    expect(() => parseYesNo('maybe', 'critical-error')).toThrow('"critical-error" must be either "yes" or "no".');
-  });
-
-  it('validates helpfulness scores', () => {
-    expect(validateHelpfulness(5)).toBe(5);
-    expect(() => validateHelpfulness(0)).toThrow(CliError);
-  });
-
-  it('reads a valid PDF file and returns metadata', async () => {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'paperreview-'));
-    const pdfPath = path.join(tempDir, 'sample.pdf');
-    const pdfBytes = Buffer.concat([Buffer.from('%PDF-1.4\n'), Buffer.alloc(256, 1)]);
-    await fs.writeFile(pdfPath, pdfBytes);
-
-    const result = await readPdfFile(pdfPath);
-
-    expect(result.fileName).toBe('sample.pdf');
-    expect(result.resolvedPath).toBe(pdfPath);
-    expect(result.sizeBytes).toBe(pdfBytes.length);
-    expect(result.buffer.equals(pdfBytes)).toBe(true);
-  });
-
-  it('rejects PDFs larger than the paperreview.ai size limit', async () => {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'paperreview-'));
-    const pdfPath = path.join(tempDir, 'large.pdf');
-    await fs.writeFile(pdfPath, Buffer.alloc(MAX_PDF_BYTES + 1, 1));
-
-    await expect(readPdfFile(pdfPath)).rejects.toThrow(CliError);
-    await expect(readPdfFile(pdfPath)).rejects.toThrow('The PDF is larger than paperreview.ai\'s 10MB limit.');
-  });
-
-  it('normalizes fetch failures into CliError', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('socket hang up')));
-
-    await expect(requestJson('/api/review/token')).rejects.toThrow(CliError);
-    await expect(requestJson('/api/review/token')).rejects.toThrow('Unable to reach paperreview.ai');
-  });
-});