openrxiv 0.0.0

package/dist/cli/src/commands/download.js

@@ -0,0 +1,76 @@
+import { Command } from 'commander';
+import axios from 'axios';
+import { downloadFile } from '../aws/downloader.js';
+import { setGlobalRequesterPays } from '../aws/config.js';
+import { displayRequesterPaysError } from '../utils/requester-pays-error.js';
+export const downloadCommand = new Command('download')
+    .description('Download MECA files from the bioRxiv/medRxiv S3 bucket by DOI')
+    .argument('<doi>', 'DOI of the paper (e.g., "10.1101/2024.01.15.123456")')
+    .option('-o, --output <dir>', 'Output directory for downloaded files', './downloads')
+    .option('-a, --api-url <url>', 'API base URL', 'https://biorxiv.curvenote.dev')
+    .option('--requester-pays', 'Enable requester-pays for S3 bucket access')
+    .action(async (doi, options) => {
+    var _a, _b, _c;
+    try {
+        // Validate DOI format
+        if (!doi.includes('/')) {
+            console.error('❌ Invalid DOI format. Expected format: 10.1101/2024.01.15.123456');
+            process.exit(1);
+        }
+        // Split DOI into prefix and suffix
+        const [doiPrefix, doiSuffix] = doi.split('/', 2);
+        console.log(`🔍 Looking up paper with DOI: ${doi}`);
+        console.log(`📡 API URL: ${options.apiUrl}`);
+        // Look up the paper in the API
+        const response = await axios.get(`${options.apiUrl}/v1/works/${doiPrefix}/${doiSuffix}`);
+        if (!response.data || !response.data.s3Key) {
+            console.error('❌ Paper not found or no S3 key available');
+            process.exit(1);
+        }
+        const paper = response.data;
+        console.log(`📄 Found paper: ${paper.title || 'Unknown title'}`);
+        console.log(`📦 S3 Key: ${paper.s3Key}`);
+        // Set requester-pays if flag is provided
+        if (options.requesterPays) {
+            setGlobalRequesterPays(true);
+            console.log(`💰 Requester-pays enabled for S3 access`);
+        }
+        // Create a filesystem-safe filename from the DOI
+        const safeDoi = doi.replace(/[^a-zA-Z0-9.-]/g, '_');
+        const filename = `${safeDoi}.meca`;
+        console.log(`📥 Downloading MECA file as: ${filename}`);
+        // Download the file using the S3 key from the API
+        try {
+            await downloadFile(paper.s3Key, { ...options, filename });
+            console.log(`✅ Successfully downloaded MECA file for DOI: ${doi}`);
+        }
+        catch (downloadError) {
+            // Check if it's a requester-pays related error
+            const errorMessage = downloadError instanceof Error ? downloadError.message : String(downloadError);
+            if (errorMessage.includes('UnknownError') || errorMessage.includes('AccessDenied')) {
+                displayRequesterPaysError();
+            }
+            else {
+                console.error('❌ Download failed:', errorMessage);
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                console.error('❌ Article not found with the specified DOI');
+            }
+            else if (((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) === 401) {
+                console.error('❌ Authentication failed. Please check your API key');
+            }
+            else {
+                console.error('❌ API error:', ((_c = error.response) === null || _c === void 0 ? void 0 : _c.data) || error.message);
+            }
+        }
+        else {
+            console.error('❌ Error looking up paper:', error);
+        }
+        process.exit(1);
+    }
+});

package/dist/cli/src/commands/list.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const listCommand: Command;
+//# sourceMappingURL=list.d.ts.map

package/dist/cli/src/commands/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../src/commands/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,eAAO,MAAM,WAAW,SAapB,CAAC"}

package/dist/cli/src/commands/list.js

@@ -0,0 +1,18 @@
+import { Command } from 'commander';
+import { listBucketContent } from '../aws/bucket-explorer.js';
+import { getDefaultServer } from '../utils/index.js';
+export const listCommand = new Command('list')
+    .description('List available content in the bioRxiv or medRxiv S3 bucket')
+    .option('-m, --month <month>', 'Filter by specific month (e.g., "2024-01")')
+    .option('-b, --batch <batch>', 'Filter by specific batch (e.g., "Batch_01")')
+    .option('-l, --limit <number>', 'Limit the number of results', '50')
+    .option('-s, --server <server>', 'Server to use: "biorxiv" or "medrxiv"', getDefaultServer())
+    .action(async (options) => {
+    try {
+        await listBucketContent(options);
+    }
+    catch (error) {
+        console.error('Error listing content:', error);
+        process.exit(1);
+    }
+});

package/dist/cli/src/commands/month-info.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const monthInfoCommand: Command;
+//# sourceMappingURL=month-info.d.ts.map

package/dist/cli/src/commands/month-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"month-info.d.ts","sourceRoot":"","sources":["../../../../src/commands/month-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQpC,eAAO,MAAM,gBAAgB,SAczB,CAAC"}

package/dist/cli/src/commands/month-info.js

@@ -0,0 +1,213 @@
+import { Command } from 'commander';
+import { ListObjectsV2Command } from '@aws-sdk/client-s3';
+import chalk from 'chalk';
+import { getS3Client } from '../aws/config.js';
+import { getFolderStructure } from 'biorxiv-utils';
+import { getBucketName } from '../aws/bucket-explorer.js';
+import { getDefaultServer } from '../utils/index.js';
+export const monthInfoCommand = new Command('month-info')
+    .description('List detailed metadata for all files in a specific month or batch from bioRxiv or medRxiv')
+    .option('-m, --month <month>', 'Month to list (e.g., "January_2024" or "2024-01")')
+    .option('-b, --batch <batch>', 'Batch to list (e.g., "1", "batch-1", "Batch_01")')
+    .option('-s, --server <server>', 'Server to use: "biorxiv" or "medrxiv"', getDefaultServer())
+    .action(async (options) => {
+    try {
+        await listMonthMetadata(options);
+    }
+    catch (error) {
+        console.error('Error listing month metadata:', error);
+        process.exit(1);
+    }
+});
+async function listMonthMetadata(options) {
+    const client = await getS3Client();
+    const { month, batch, server = getDefaultServer() } = options;
+    const bucketName = getBucketName(server);
+    if (!month && !batch) {
+        console.error('❌ Error: Either --month or --batch option must be specified');
+        process.exit(1);
+    }
+    // Determine folder structure based on options
+    const contentStructure = getFolderStructure({ month, batch, server });
+    const prefix = contentStructure.prefix;
+    const description = month ? `Month: ${month}` : `Batch: ${batch}`;
+    console.log(chalk.blue(`📅 Month/Batch Information: ${description}`));
+    console.log(chalk.blue('===================================='));
+    console.log(chalk.gray(`🔍 Content Type: ${contentStructure.type === 'current' ? 'Current Content' : 'Back Content'}`));
+    if (contentStructure.batch) {
+        console.log(chalk.gray(`🔍 Batch: ${contentStructure.batch}`));
+    }
+    console.log(chalk.gray(`🔍 Scanning S3 prefix: ${prefix}`));
+    console.log('');
+    const allFiles = [];
+    let continuationToken;
+    let batchCount = 0;
+    try {
+        // Use pagination to get all files
+        do {
+            batchCount++;
+            console.log(chalk.gray(`📦 Fetching batch ${batchCount}...`));
+            const command = new ListObjectsV2Command({
+                Bucket: bucketName,
+                Prefix: prefix,
+                MaxKeys: 1000,
+                ContinuationToken: continuationToken,
+                RequestPayer: 'requester',
+            });
+            const response = await client.send(command);
+            if (response.Contents) {
+                for (const item of response.Contents) {
+                    if (!item.Key)
+                        continue;
+                    const type = getContentType(item.Key);
+                    allFiles.push({
+                        key: item.Key,
+                        size: item.Size || 0,
+                        lastModified: item.LastModified || new Date(),
+                        type,
+                        fileName: item.Key.split('/').pop() || 'unknown',
+                        fileExtension: item.Key.split('.').pop() || 'none',
+                    });
+                }
+            }
+            continuationToken = response.NextContinuationToken;
+            if (response.Contents) {
+                console.log(chalk.gray(`   Found ${response.Contents.length} files in this batch`));
+            }
+        } while (continuationToken);
+        console.log(chalk.green(`✅ Total files found: ${allFiles.length}`));
+        console.log('');
+        displaySummary(allFiles, month || batch || 'unknown', server);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to list month metadata: ${error.message}`);
+        }
+        throw error;
+    }
+}
+function getContentType(key) {
+    if (key.endsWith('.meca'))
+        return 'meca';
+    if (key.endsWith('.pdf'))
+        return 'pdf';
+    if (key.endsWith('.xml'))
+        return 'xml';
+    return 'other';
+}
+function displaySummary(files, month, server = getDefaultServer()) {
+    console.log(chalk.blue.bold('📊 Summary Statistics'));
+    console.log(chalk.blue('===================='));
+    console.log('');
+    // Show content structure info if available
+    try {
+        const contentStructure = getFolderStructure({ month, server });
+        console.log(chalk.cyan('📁 Content Structure:'));
+        console.log(`   Type: ${chalk.yellow(contentStructure.type === 'current' ? 'Current Content' : 'Back Content')}`);
+        if (contentStructure.batch) {
+            console.log(`   Batch: ${chalk.yellow(contentStructure.batch)}`);
+        }
+        console.log('');
+    }
+    catch (error) {
+        // Ignore errors in summary display
+    }
+    // File type breakdown
+    const typeCounts = files.reduce((acc, file) => {
+        acc[file.type] = (acc[file.type] || 0) + 1;
+        return acc;
+    }, {});
+    console.log(chalk.cyan('📁 File Types:'));
+    for (const [type, count] of Object.entries(typeCounts)) {
+        const percentage = ((count / files.length) * 100).toFixed(1);
+        console.log(`   ${chalk.yellow(type.toUpperCase())}: ${chalk.green(count)} (${percentage}%)`);
+    }
+    console.log('');
+    // Size statistics
+    const mecaFiles = files.filter((f) => f.type === 'meca');
+    if (mecaFiles.length > 0) {
+        const sizes = mecaFiles.map((f) => f.size);
+        const totalSize = sizes.reduce((sum, size) => sum + size, 0);
+        const avgSize = totalSize / sizes.length;
+        const minSize = Math.min(...sizes);
+        const maxSize = Math.max(...sizes);
+        console.log(chalk.cyan('📦 MECA File Sizes:'));
+        console.log(`   Total: ${chalk.green(formatFileSize(totalSize))}`);
+        console.log(`   Average: ${chalk.green(formatFileSize(avgSize))}`);
+        console.log(`   Range: ${chalk.green(formatFileSize(minSize))} - ${chalk.green(formatFileSize(maxSize))}`);
+        console.log('');
+    }
+    // Date range
+    const dates = files.map((f) => f.lastModified);
+    const earliest = new Date(Math.min(...dates.map((d) => d.getTime())));
+    const latest = new Date(Math.max(...dates.map((d) => d.getTime())));
+    console.log(chalk.cyan('📅 Upload Date Range:'));
+    console.log(`   Earliest: ${chalk.green(earliest.toLocaleDateString())}`);
+    console.log(`   Latest: ${chalk.green(latest.toLocaleDateString())}`);
+    console.log('');
+    // Upload date histogram
+    const sortedDates = displayUploadDateHistogram(files);
+    console.log('');
+    // Show batch analysis
+    console.log('');
+    analyzeBatchPatterns(sortedDates);
+}
+function displayUploadDateHistogram(files) {
+    console.log(chalk.cyan('📊 Upload Date Distribution:'));
+    console.log(chalk.cyan('============================'));
+    console.log('');
+    // Group files by date
+    const dateGroups = new Map();
+    for (const file of files) {
+        const dateKey = file.lastModified.toLocaleDateString();
+        dateGroups.set(dateKey, (dateGroups.get(dateKey) || 0) + 1);
+    }
+    // Sort dates chronologically
+    const sortedDates = Array.from(dateGroups.entries()).sort((a, b) => {
+        return new Date(a[0]).getTime() - new Date(b[0]).getTime();
+    });
+    // Find the maximum count for scaling
+    const maxCount = Math.max(...Array.from(dateGroups.values()));
+    const maxBarLength = 50; // Maximum bar length in characters
+    // Display histogram
+    for (const [date, count] of sortedDates) {
+        const barLength = Math.round((count / maxCount) * maxBarLength);
+        const bar = '█'.repeat(barLength);
+        const percentage = ((count / files.length) * 100).toFixed(1);
+        // Color code by upload volume
+        let countColor = chalk.green;
+        if (count > maxCount * 0.8) {
+            countColor = chalk.red; // High volume
+        }
+        else if (count > maxCount * 0.5) {
+            countColor = chalk.yellow; // Medium volume
+        }
+        else {
+            countColor = chalk.green; // Low volume
+        }
+        console.log(`${chalk.cyan(date.padStart(10))} ${countColor(count.toString().padStart(4))} ${chalk.gray('│')} ${chalk.blue(bar)} ${chalk.gray(`(${percentage}%)`)}`);
+    }
+    return sortedDates;
+}
+function analyzeBatchPatterns(dateGroups) {
+    console.log(chalk.cyan('🔍 Batch Analysis'));
+    console.log(chalk.cyan('================='));
+    console.log('');
+    if (dateGroups.length === 0)
+        return;
+    // Analyze upload patterns
+    const totalDays = dateGroups.length;
+    const totalFiles = dateGroups.reduce((sum, [, count]) => sum + count, 0);
+    const avgFilesPerDay = totalFiles / totalDays;
+    console.log(`   Total active days: ${chalk.green(totalDays)}`);
+    console.log(`   Average files per day: ${chalk.green(avgFilesPerDay.toFixed(1))}`);
+    console.log('');
+}
+function formatFileSize(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}

package/dist/cli/src/commands/summary.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const summaryCommand: Command;
+//# sourceMappingURL=summary.d.ts.map

package/dist/cli/src/commands/summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summary.d.ts","sourceRoot":"","sources":["../../../../src/commands/summary.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC,eAAO,MAAM,cAAc,SAyGvB,CAAC"}

package/dist/cli/src/commands/summary.js

@@ -0,0 +1,249 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { createOpenRxivApiClient, getServerFromDOI } from '../api/api-client.js';
+import { parseBiorxivURL } from 'biorxiv-utils';
+import { getDefaultServer } from '../utils/index.js';
+export const summaryCommand = new Command('summary')
+    .description('Get a summary of a bioRxiv preprint from a URL or DOI')
+    .argument('<url-or-doi>', 'bioRxiv URL or DOI to summarize')
+    .option('-m, --more', 'Show additional details and full abstract')
+    .option('-s, --server <server>', 'Specify server (biorxiv or medrxiv)', getDefaultServer())
+    .action(async (urlOrDoi, options) => {
+    var _a, _b;
+    try {
+        console.log(chalk.blue.bold(`🔬 ${(_a = options.server) !== null && _a !== void 0 ? _a : ''} Preprint Summary`));
+        console.log(chalk.blue('================================\n'));
+        // Parse the input (could be URL or DOI)
+        let doi;
+        let parsedUrl = null;
+        if (urlOrDoi.includes('biorxiv.org') ||
+            urlOrDoi.includes('medrxiv.org') ||
+            urlOrDoi.includes('doi.org')) {
+            // It's a URL
+            parsedUrl = parseBiorxivURL(urlOrDoi);
+            if (!parsedUrl) {
+                console.log(chalk.red('❌ Invalid bioRxiv URL'));
+                process.exit(1);
+            }
+            doi = parsedUrl.doi;
+            console.log(chalk.cyan(`📝 URL: ${urlOrDoi}`));
+        }
+        else {
+            // It's a DOI
+            doi = urlOrDoi;
+            console.log(chalk.cyan(`🔍 DOI: ${doi}`));
+        }
+        console.log('');
+        // Determine server if possible
+        let server = (_b = options.server) !== null && _b !== void 0 ? _b : getServerFromDOI(urlOrDoi);
+        console.log(chalk.blue(`🌐 Server: ${server}`));
+        console.log('');
+        // Create API client
+        const apiClient = createOpenRxivApiClient({
+            server,
+            format: 'json',
+            timeout: 15000,
+        });
+        // Show loading indicator
+        console.log(chalk.yellow('⏳ Fetching preprint information...'));
+        console.log('');
+        // Get content details
+        let contentDetail = await apiClient.getContentDetail(doi);
+        let fallbackServer = null;
+        // If not found on bioRxiv and we're not already on medrxiv, try medrxiv as fallback
+        if (!contentDetail && server === 'biorxiv') {
+            console.log(chalk.yellow('⚠️  Paper not found on bioRxiv, trying medRxiv...'));
+            fallbackServer = 'medrxiv';
+            const medrxivApiClient = createOpenRxivApiClient({
+                server: 'medrxiv',
+                format: 'json',
+                timeout: 15000,
+            });
+            contentDetail = await medrxivApiClient.getContentDetail(doi);
+            if (contentDetail) {
+                console.log(chalk.green('✅ Found paper on medRxiv!'));
+                server = 'medrxiv'; // Update server for display
+                contentDetail.server = 'medrxiv'; // Ensure the content detail has the correct server
+            }
+        }
+        if (!contentDetail) {
+            console.log(chalk.red('❌ No content found for this DOI on either bioRxiv or medRxiv'));
+            console.log(chalk.yellow("💡 This might be a new preprint that hasn't been indexed yet"));
+            process.exit(1);
+        }
+        // Get all versions
+        let allVersions = await apiClient.getAllVersions(doi);
+        // If we used fallback, get versions from the fallback server
+        if (fallbackServer && contentDetail) {
+            const fallbackApiClient = createOpenRxivApiClient({
+                server: fallbackServer,
+                format: 'json',
+                timeout: 15000,
+            });
+            allVersions = await fallbackApiClient.getAllVersions(doi);
+        }
+        // Display summary
+        const isVerbose = options.more === true;
+        displaySummary(contentDetail, allVersions, isVerbose);
+    }
+    catch (error) {
+        console.error(chalk.red('❌ Error:'), error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+});
+function displaySummary(contentDetail, allVersions, verbose = false) {
+    // Title in a prominent box
+    const titleBox = boxen(chalk.green.bold.underline(contentDetail.title), {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'double',
+        borderColor: 'green',
+        backgroundColor: 'black',
+        textAlignment: 'left',
+        ...(verbose ? {} : { width: 80 }),
+    });
+    console.log(titleBox);
+    // Basic info
+    const basicInfo = [
+        `${chalk.cyan('DOI:')} ${contentDetail.doi}`,
+        `${chalk.cyan('Server:')} ${contentDetail.server}`,
+        `${chalk.cyan('Category:')} ${chalk.yellow(contentDetail.category)}`,
+        `${chalk.cyan('License:')} ${chalk.yellow(contentDetail.license)}`,
+        `${chalk.cyan('Type:')} ${chalk.yellow(contentDetail.type)}`,
+        `${chalk.cyan('Published:')} ${contentDetail.published === 'NA'
+            ? chalk.gray('Not published')
+            : chalk.green(contentDetail.published)}`,
+        `${chalk.cyan('Total versions:')} ${allVersions ? allVersions.length : 0}`,
+        ...(verbose
+            ? [
+                `${chalk.cyan('Date:')} ${contentDetail.date}`,
+                `${chalk.cyan('Version:')} ${contentDetail.version}`,
+                ...(contentDetail.jatsxml
+                    ? [`${chalk.cyan('JATS XML:')} ${chalk.underline.blue(contentDetail.jatsxml)}`]
+                    : []),
+            ]
+            : []),
+    ].join('\n');
+    const basicInfoBox = boxen(basicInfo, {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'round',
+        borderColor: 'blue',
+        title: chalk.blue.bold('📋 Basic Information'),
+        titleAlignment: 'left',
+        textAlignment: 'left',
+        ...(verbose ? {} : { width: 80 }),
+    });
+    console.log(basicInfoBox);
+    // Authors
+    const authorsInfo = [
+        `${chalk.cyan('Authors:')} ${contentDetail.authors}`,
+        ...(contentDetail.author_corresponding
+            ? [`${chalk.cyan('Corresponding:')} ${chalk.green(contentDetail.author_corresponding)}`]
+            : []),
+        ...(contentDetail.author_corresponding_institution
+            ? [
+                `${chalk.cyan('Institution:')} ${chalk.gray(contentDetail.author_corresponding_institution)}`,
+            ]
+            : []),
+    ].join('\n');
+    const authorsBox = boxen(authorsInfo, {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'round',
+        borderColor: 'cyan',
+        title: chalk.cyan.bold('👥 Authors'),
+        titleAlignment: 'left',
+        textAlignment: 'left',
+        ...(verbose ? {} : { width: 80 }),
+    });
+    console.log(authorsBox);
+    // Abstract
+    if (contentDetail.abstract) {
+        const abstractBox = boxen(contentDetail.abstract, {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'yellow',
+            title: chalk.yellow.bold('📖 Abstract'),
+            titleAlignment: 'left',
+            textAlignment: 'left',
+            ...(verbose ? {} : { width: 80 }),
+        });
+        console.log(abstractBox);
+    }
+    // Funding information
+    if (contentDetail.funding && contentDetail.funding.length > 0) {
+        const fundingInfo = contentDetail.funding
+            .map((fund, index) => {
+            let fundText = `${chalk.cyan(index + 1)}. ${chalk.green(fund.name)}`;
+            if (fund.id) {
+                fundText += `\n   ${chalk.gray('ID:')} ${fund.id} (${fund['id-type']})`;
+            }
+            if (fund.award) {
+                fundText += `\n   ${chalk.gray('Award:')} ${fund.award}`;
+            }
+            return fundText;
+        })
+            .join('\n\n');
+        const fundingBox = boxen(fundingInfo, {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'magenta',
+            title: chalk.magenta.bold('💰 Funding'),
+            titleAlignment: 'left',
+            textAlignment: 'left',
+            ...(verbose ? {} : { width: 80 }),
+        });
+        console.log(fundingBox);
+    }
+    // Versions - only show when --more is provided
+    if (verbose && allVersions && allVersions.length > 0) {
+        const versionsInfo = [
+            ...allVersions.map((version, index) => {
+                let versionText = `${chalk.cyan(`v${version.version}`)} (${version.date})`;
+                versionText += `\n   ${chalk.gray('Type:')} ${version.type}`;
+                versionText += `\n   ${chalk.gray('Title:')} ${version.title.substring(0, 60)}...`;
+                if (version.jatsxml) {
+                    versionText += `\n   ${chalk.gray('JATS XML:')} ${chalk.underline.blue(version.jatsxml)}`;
+                }
+                return versionText;
+            }),
+        ].join('\n\n');
+        const versionsBox = boxen(versionsInfo, {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'green',
+            title: chalk.green.bold('🔄 Versions'),
+            titleAlignment: 'left',
+            textAlignment: 'left',
+            ...(verbose ? {} : { width: 80 }),
+        });
+        console.log(versionsBox);
+    }
+    // Footer
+    const baseUrl = contentDetail.server === 'medrxiv'
+        ? `https://www.medrxiv.org/content/${contentDetail.doi}`
+        : `https://www.biorxiv.org/content/${contentDetail.doi}`;
+    const footerInfo = [
+        `💡 View online: ${chalk.underline.blue(baseUrl)}`,
+        ...(allVersions && allVersions.length > 1 && !verbose
+            ? [
+                `📚 This preprint has ${allVersions.length} versions. Use --more to see additional details.`,
+            ]
+            : []),
+    ].join('\n');
+    const footerBox = boxen(footerInfo, {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'round',
+        borderColor: 'gray',
+        backgroundColor: 'black',
+        textAlignment: 'left',
+        ...(verbose ? {} : { width: 80 }),
+    });
+    console.log(footerBox);
+}

package/dist/cli/src/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":""}

package/dist/cli/src/index.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { listCommand } from './commands/list.js';
+import { downloadCommand } from './commands/download.js';
+import { configCommand } from './commands/config.js';
+import { summaryCommand } from './commands/summary.js';
+import { monthInfoCommand } from './commands/month-info.js';
+import { batchProcessCommand } from './commands/batch-process.js';
+import { setGlobalRequesterPays } from './aws/config.js';
+import version from './version.js';
+import { getCliName } from './utils/index.js';
+const cliName = getCliName();
+const program = new Command();
+program
+    .name(cliName)
+    .description(`CLI tool to download bioRxiv/medRxiv MECA files from AWS S3 for text and data mining`)
+    .version(`v${version}`, '-v, --version', `Print the current version of the ${cliName} CLI`);
+// Add commands
+program.addCommand(listCommand);
+program.addCommand(downloadCommand);
+program.addCommand(configCommand);
+program.addCommand(summaryCommand);
+program.addCommand(monthInfoCommand);
+program.addCommand(batchProcessCommand);
+// Global options
+program.option('-d, --debug', 'Enable debug mode');
+program.option('--requester-pays', 'Enable requester pays for local development (required when not on EC2 with IAM role)');
+// Parse command line arguments
+program.parse();
+// Set global requester pays based on command line option
+const options = program.opts();
+if (options.requesterPays) {
+    setGlobalRequesterPays(true);
+    console.log('Requester pays enabled - you will be charged for S3 requests');
+}

package/dist/cli/src/utils/batches.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parse batch input to support ranges like "1-10" or "batch-1,batch-2"
+ */
+export declare function parseBatchInput(batchInput: string): string[];
+/**
+ * Validate batch format
+ */
+export declare function validateBatchFormat(batch: string): boolean;
+//# sourceMappingURL=batches.d.ts.map

package/dist/cli/src/utils/batches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batches.d.ts","sourceRoot":"","sources":["../../../../src/utils/batches.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAgE5D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAG1D"}