byterover-cli 1.3.0 → 1.4.0

package/README.md

@@ -1,6 +1,6 @@
 # ByteRover CLI
 
-Command-line interface for ByteRover, featuring an interactive REPL with a modern React/Ink terminal UI for managing your project's context tree and knowledge storage. Seamlessly integrate with 18 AI coding agents via modern skill files, MCP tools, or rules-based integration—supports Claude Code, Cursor, Windsurf, GitHub Copilot, Cline, and 13 more.
+Command-line interface for ByteRover, featuring an interactive REPL with a modern React/Ink terminal UI for managing your project's context tree and knowledge storage. Seamlessly integrate with 19 AI coding agents via modern skill files, MCP tools, or rules-based integration—supports Claude Code, Cursor, Windsurf, GitHub Copilot, Cline, and more.
 
 [![Version](https://img.shields.io/npm/v/byterover-cli.svg)](https://npmjs.org/package/byterover-cli)
 [![Downloads/week](https://img.shields.io/npm/dw/byterover-cli.svg)](https://npmjs.org/package/byterover-cli)
@@ -154,7 +154,7 @@ The **Context Tree** is ByteRover's structured knowledge system that helps you a
 - **Organized Knowledge**: Structure your project knowledge by domain and topic
 - **Easy Retrieval**: Find relevant context quickly when you need it
 - **Persistent Memory**: Maintain project-specific knowledge across sessions
-- **Agent-Friendly**: Works seamlessly with 18 AI coding agents (Claude Code, Cursor, Windsurf, GitHub Copilot, Cline, and 13 more) via skill files, MCP tools, hooks, or rules
+- **Agent-Friendly**: Works seamlessly with 19 AI coding agents (Claude Code, Cursor, Windsurf, GitHub Copilot, Cline, and more) via skill files, MCP tools, hooks, or rules
 - **Cloud Sync**: Push and sync your context tree to ByteRover's cloud storage for backup and team collaboration
 - **Dynamic Domains**: Automatically creates new domains as your knowledge grows
 
@@ -167,13 +167,16 @@ The context tree organizes knowledge into:
 
 ## Supported AI Agents
 
-ByteRover integrates with 18 AI coding agents:
+ByteRover integrates with 19 AI coding agents:
 
 **Skill Connector (Default):**
 - Claude Code, Cursor
 
 **MCP Connector (Default):**
-- Amp, Augment Code, Cline, Gemini CLI, Github Copilot, Junie, Kilo Code, Kiro, Qoder, Qwen Code, Roo Code, Trae.ai, Warp, Windsurf, Zed (and Codex via global scope)
+- Amp, Augment Code, Cline, Codex, Gemini CLI, Github Copilot, Junie, Kilo Code, Kiro, Qoder, Qwen Code, Roo Code, Trae.ai, Warp, Windsurf, Zed
+
+**Rules Connector (Default):**
+- Antigravity (rules-only integration)
 
 **All agents support rules-based integration as a universal fallback option.**
 
@@ -190,12 +193,13 @@ Use `/connectors` to manage integrations with your AI coding agents:
 ByteRover supports four connector types:
 
 1. **Skill integration** (Claude Code, Cursor - default): Modern integration that writes 3 markdown files (SKILL.md, TROUBLESHOOTING.md, WORKFLOWS.md) to your agent's skills directory for easy discovery and guidance
-2. **MCP integration** (16 other agents - default): Exposes brv-query and brv-curate as Model Context Protocol tools that AI agents can call directly
+2. **MCP integration** (16 agents - default): Exposes brv-query and brv-curate as Model Context Protocol tools that AI agents can call directly
 3. **Rules-based** (all agents): Generates agent-specific rule files (e.g., CLAUDE.md, .cursorrules) with instructions for using ByteRover
 4. **Hook integration** (Claude Code only - legacy): Direct injection via IDE settings, replaced by skill connector
 
 **Defaults by agent:**
 - Claude Code, Cursor: Skill connector
+- Antigravity: Rules connector (only supported type)
 - All others (16 agents): MCP connector
 - Rules: Available for all agents as fallback
 
@@ -269,6 +273,7 @@ ByteRover supports four connector types:
 
 **Defaults:**
 - Claude Code, Cursor: `skill`
+- Antigravity: `rules` (only supported type)
 - All others: `mcp`
 
 **Reset options:**

package/dist/core/domain/cipher/errors/file-system-error.d.ts

@@ -210,3 +210,14 @@ export declare class TooManyResultsError extends FileSystemError {
      */
     constructor(operation: string, count: number, maxResults: number);
 }
+/**
+ * Error thrown when PDF text extraction fails.
+ */
+export declare class PdfExtractionError extends FileSystemError {
+    /**
+     * Creates a new PDF extraction error
+     * @param path - Path to the PDF file
+     * @param reason - Reason for the extraction failure
+     */
+    constructor(path: string, reason: string);
+}

package/dist/core/domain/cipher/errors/file-system-error.js

@@ -290,3 +290,20 @@ export class TooManyResultsError extends FileSystemError {
         this.name = 'TooManyResultsError';
     }
 }
+/**
+ * Error thrown when PDF text extraction fails.
+ */
+export class PdfExtractionError extends FileSystemError {
+    /**
+     * Creates a new PDF extraction error
+     * @param path - Path to the PDF file
+     * @param reason - Reason for the extraction failure
+     */
+    constructor(path, reason) {
+        super(`Failed to extract text from PDF: ${path}. ${reason}`, 'PDF_EXTRACTION_FAILED', {
+            path,
+            reason,
+        });
+        this.name = 'PdfExtractionError';
+    }
+}

package/dist/core/domain/cipher/file-system/types.d.ts

@@ -18,16 +18,46 @@ export interface FileSystemConfig {
     /** Working directory for relative path resolution */
     workingDirectory: string;
 }
+/**
+ * PDF read mode for controlling how PDF files are returned.
+ * - 'text': Extract text content page by page (default)
+ * - 'base64': Return raw PDF as base64 attachment (for multimodal LLMs)
+ */
+export type PdfReadMode = 'base64' | 'text';
+/**
+ * Metadata extracted from a PDF file.
+ */
+export interface PdfMetadata {
+    /** Author of the PDF (if available) */
+    author?: string;
+    /** Creation date of the PDF (if available) */
+    creationDate?: Date;
+    /** Total number of pages in the PDF */
+    pageCount: number;
+    /** Title of the PDF (if available) */
+    title?: string;
+}
+/**
+ * Content extracted from a single PDF page.
+ */
+export interface PdfPageContent {
+    /** 1-based page number */
+    pageNumber: number;
+    /** Extracted text content from the page */
+    text: string;
+}
 /**
  * Options for reading files.
  */
 export interface ReadFileOptions {
     /** Character encoding */
     encoding?: BufferEncoding;
-    /** Maximum number of lines to read */
+    /** Maximum number of lines to read (for text files) or pages (for PDFs in text mode) */
     limit?: number;
-    /** Starting line number (1-based, like text editors) */
+    /** Starting line number (1-based) for text files, or starting page number for PDFs */
     offset?: number;
+    /** PDF read mode: 'text' (default) extracts text, 'base64' returns raw attachment */
+    pdfMode?: PdfReadMode;
 }
 /**
  * Options for writing files.
@@ -126,23 +156,27 @@ export interface FileAttachment {
  * Result of a file read operation.
  */
 export interface FileContent {
-    /** Attachment data for binary files (images, PDFs) */
+    /** Attachment data for binary files (images, PDFs in base64 mode) */
     attachment?: FileAttachment;
     /** File content as string */
     content: string;
     /** Character encoding used */
     encoding: string;
-    /** Formatted content with line numbers (00001| content format) */
+    /** Formatted content with line numbers (00001| content format) or PDF page separators */
     formattedContent: string;
-    /** Total number of lines in the returned content */
+    /** Total number of lines in the returned content (or pages for PDF text mode) */
     lines: number;
     /** Human-readable message about file status (truncation info, etc.) */
     message: string;
+    /** PDF metadata when reading PDF in text mode */
+    pdfMetadata?: PdfMetadata;
+    /** PDF page contents when reading PDF in text mode */
+    pdfPages?: PdfPageContent[];
     /** Preview of content (first 20 lines) for UI display */
     preview?: string;
     /** File size in bytes */
     size: number;
-    /** Total lines in the entire file */
+    /** Total lines in the entire file (or total pages for PDF text mode) */
     totalLines: number;
     /** Whether content was truncated due to size/line limits */
     truncated: boolean;

package/dist/core/domain/entities/agent.d.ts

@@ -2,7 +2,7 @@ import type { ConnectorType } from './connector-type.js';
 /**
  * Array of all supported Agents.
  */
-export declare const AGENT_VALUES: readonly ["Amp", "Augment Code", "Claude Code", "Cline", "Codex", "Cursor", "Gemini CLI", "Github Copilot", "Junie", "Kilo Code", "Kiro", "Qoder", "Qwen Code", "Roo Code", "Trae.ai", "Warp", "Windsurf", "Zed"];
+export declare const AGENT_VALUES: readonly ["Amp", "Antigravity", "Augment Code", "Claude Code", "Cline", "Codex", "Cursor", "Gemini CLI", "Github Copilot", "Junie", "Kilo Code", "Kiro", "Qoder", "Qwen Code", "Roo Code", "Trae.ai", "Warp", "Windsurf", "Zed"];
 export type Agent = (typeof AGENT_VALUES)[number];
 /**
  * Connector availability configuration for an agent.

package/dist/core/domain/entities/agent.js

@@ -3,6 +3,7 @@
  */
 export const AGENT_VALUES = [
     'Amp',
+    'Antigravity',
     'Augment Code',
     'Claude Code',
     'Cline',
@@ -30,6 +31,10 @@ export const AGENT_CONNECTOR_CONFIG = {
         default: 'mcp',
         supported: ['rules', 'mcp'],
     },
+    Antigravity: {
+        default: 'rules',
+        supported: ['rules'],
+    },
     'Augment Code': {
         default: 'mcp',
         supported: ['rules', 'mcp'],

package/dist/core/interfaces/cipher/cipher-services.d.ts

@@ -8,7 +8,6 @@ import type { SystemPromptManager } from '../../../infra/cipher/system-prompt/sy
 import type { ToolManager } from '../../../infra/cipher/tools/tool-manager.js';
 import type { ToolProvider } from '../../../infra/cipher/tools/tool-provider.js';
 import type { IBlobStorage } from './i-blob-storage.js';
-import type { ICodingAgentLogWatcher } from './i-coding-agent-log-watcher.js';
 import type { IHistoryStorage } from './i-history-storage.js';
 import type { ILLMService } from './i-llm-service.js';
 import type { IPolicyEngine } from './i-policy-engine.js';
@@ -28,12 +27,10 @@ import type { IToolScheduler } from './i-tool-scheduler.js';
  * - HistoryStorage: Conversation history persistence
  * - MemoryManager: Agent memory system
  * - ToolProvider: Provides available tools
- * - CodingAgentLogWatcher: Watches coding agent logs for learning (optional)
  */
 export interface CipherAgentServices {
     agentEventBus: AgentEventBus;
     blobStorage: IBlobStorage;
-    codingAgentLogWatcher?: ICodingAgentLogWatcher;
     /**
      * CompactionService for context overflow management.
      * Only available when granular storage is enabled (useGranularStorage: true).

package/dist/core/interfaces/cipher/index.d.ts

@@ -8,8 +8,6 @@ export * from './cipher-services.js';
 export type { IBlobStorage } from './i-blob-storage.js';
 export type { IChatSession } from './i-chat-session.js';
 export type { ICipherAgent } from './i-cipher-agent.js';
-export type { ICodingAgentLogParser } from './i-coding-agent-log-parser.js';
-export type { ICodingAgentLogWatcher } from './i-coding-agent-log-watcher.js';
 export type { IContentGenerator } from './i-content-generator.js';
 export type { IEventEmitter } from './i-event-emitter.js';
 export type { IFileSystem } from './i-file-system.js';

package/dist/infra/cipher/file-system/binary-utils.d.ts

@@ -33,6 +33,19 @@ export declare function isPdfFile(filePath: string, buffer?: Buffer): boolean;
  */
 export declare function getMimeType(filePath: string): null | string;
 /**
- * Checks if a file is a media file (image or PDF) for base64 attachment handling.
+ * Checks if a file is a media file (only images supported at this point). PDFs are handled separately.
+ * @param filePath - Path to the file
+ */
+export declare function isMediaFile(filePath: string): boolean;
+/**
+ * Determines if a file should be returned as a base64 attachment.
+ *
+ * - Images: Always returned as attachment
+ * - PDFs: Depends on pdfMode ('base64' = attachment, 'text' = extract text)
+ * - Other files: Never returned as attachment
+ *
+ * @param filePath - Path to the file
+ * @param pdfMode - PDF read mode ('text' | 'base64'), defaults to 'text'
+ * @returns true if file should be returned as base64 attachment
  */
-export declare function isMediaFile(filePath: string, buffer?: Buffer): boolean;
+export declare function shouldReturnAsAttachment(filePath: string, pdfMode?: 'base64' | 'text'): boolean;

package/dist/infra/cipher/file-system/binary-utils.js

@@ -172,8 +172,31 @@ export function getMimeType(filePath) {
     return MIME_TYPES[ext] ?? null;
 }
 /**
- * Checks if a file is a media file (image or PDF) for base64 attachment handling.
+ * Checks if a file is a media file (only images supported at this point). PDFs are handled separately.
+ * @param filePath - Path to the file
  */
-export function isMediaFile(filePath, buffer) {
-    return isImageFile(filePath) || isPdfFile(filePath, buffer);
+export function isMediaFile(filePath) {
+    return isImageFile(filePath);
+}
+/**
+ * Determines if a file should be returned as a base64 attachment.
+ *
+ * - Images: Always returned as attachment
+ * - PDFs: Depends on pdfMode ('base64' = attachment, 'text' = extract text)
+ * - Other files: Never returned as attachment
+ *
+ * @param filePath - Path to the file
+ * @param pdfMode - PDF read mode ('text' | 'base64'), defaults to 'text'
+ * @returns true if file should be returned as base64 attachment
+ */
+export function shouldReturnAsAttachment(filePath, pdfMode) {
+    // Images are always returned as attachments
+    if (isImageFile(filePath)) {
+        return true;
+    }
+    // PDFs depend on pdfMode (if pdfMode is 'base64', return true)
+    if (isPdfFile(filePath) && pdfMode === 'base64') {
+        return true;
+    }
+    return false;
 }

package/dist/infra/cipher/file-system/file-system-service.d.ts

@@ -89,6 +89,15 @@ export declare class FileSystemService implements IFileSystem {
      * Returns null if grep is not available or fails.
      */
     private executeSystemGrep;
+    /**
+     * Extracts text content from a PDF file with pagination support.
+     * @param buffer - PDF file buffer
+     * @param filePath - Path to the PDF file
+     * @param fileSize - Size of the file in bytes
+     * @param options - Read options including offset and limit
+     * @returns FileContent with extracted text
+     */
+    private extractPdfTextContent;
     /**
      * Checks if a command is available in the system's PATH.
      */

package/dist/infra/cipher/file-system/file-system-service.js

@@ -3,12 +3,13 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs/promises';
 import { EOL } from 'node:os';
 import path from 'node:path';
-import { DirectoryNotFoundError, EditOperationError, FileNotFoundError, FileTooLargeError, GlobOperationError, InvalidExtensionError, InvalidPathError, InvalidPatternError, PathBlockedError, PathNotAllowedError, PathTraversalError, ReadOperationError, SearchOperationError, ServiceNotInitializedError, StringNotFoundError, StringNotUniqueError, WriteOperationError, } from '../../../core/domain/cipher/errors/file-system-error.js';
+import { DirectoryNotFoundError, EditOperationError, FileNotFoundError, FileTooLargeError, GlobOperationError, InvalidExtensionError, InvalidPathError, InvalidPatternError, PathBlockedError, PathNotAllowedError, PathTraversalError, PdfExtractionError, ReadOperationError, SearchOperationError, ServiceNotInitializedError, StringNotFoundError, StringNotUniqueError, WriteOperationError, } from '../../../core/domain/cipher/errors/file-system-error.js';
 import { getErrorMessage } from '../../../utils/error-helpers.js';
-import { getMimeType, isBinaryFile, isMediaFile, isPdfFile } from './binary-utils.js';
+import { getMimeType, isBinaryFile, isImageFile, isPdfFile, shouldReturnAsAttachment } from './binary-utils.js';
 import { createGitignoreFilter } from './gitignore-filter.js';
 import { collectFileMetadata, escapeIfExactMatch, extractPaths, sortFilesByRecency } from './glob-utils.js';
 import { PathValidator } from './path-validator.js';
+import { formatPdfContent, PdfExtractor } from './pdf-extractor.js';
 /**
  * Maximum line length for search results.
  * Prevents context overflow from minified files or long lines.
@@ -434,12 +435,12 @@ export class FileSystemService {
             if (stats.size > this.config.maxFileSize) {
                 throw new FileTooLargeError(normalizedPath, stats.size, this.config.maxFileSize);
             }
-            // Handle image/PDF files - return as base64 attachment
-            if (isMediaFile(normalizedPath)) {
+            // Handle files that should be returned as base64 attachments (images always, PDFs when pdfMode='base64')
+            if (shouldReturnAsAttachment(normalizedPath, options.pdfMode)) {
                 const buffer = await fs.readFile(normalizedPath);
-                const mimeType = getMimeType(normalizedPath) ?? 'application/octet-stream';
-                const fileType = isPdfFile(normalizedPath) ? 'PDF' : 'Image';
                 const baseName = path.basename(normalizedPath);
+                const mimeType = getMimeType(normalizedPath) ?? 'application/octet-stream';
+                const fileType = isImageFile(normalizedPath) ? 'Image' : 'PDF';
                 return {
                     attachment: {
                         base64: buffer.toString('base64'),
@@ -456,6 +457,11 @@ export class FileSystemService {
                     truncated: false,
                 };
             }
+            // Handle PDF files with text extraction (pdfMode='text')
+            if (isPdfFile(normalizedPath)) {
+                const buffer = await fs.readFile(normalizedPath);
+                return this.extractPdfTextContent(buffer, normalizedPath, stats.size, options);
+            }
             // Check for binary files (read first 4KB for detection)
             const handle = await fs.open(normalizedPath, 'r');
             const sampleBuffer = Buffer.alloc(BINARY_DETECTION_BUFFER_SIZE);
@@ -486,7 +492,7 @@ export class FileSystemService {
             if (truncated) {
                 const remainingLines = totalLines - lastReadLine;
                 message =
-                    `Read lines ${offset + 1}-${lastReadLine} of ${totalLines} total lines. ` +
+                    `Read lines ${offset + 1}-${lastReadLine}. ` +
                         `${remainingLines} more lines available. Use offset=${lastReadLine + 1} to continue reading.`;
             }
             else {
@@ -520,7 +526,8 @@ export class FileSystemService {
                 error instanceof PathNotAllowedError ||
                 error instanceof PathTraversalError ||
                 error instanceof PathBlockedError ||
-                error instanceof ReadOperationError) {
+                error instanceof ReadOperationError ||
+                error instanceof PdfExtractionError) {
                 throw error;
             }
             // Wrap other errors
@@ -725,6 +732,82 @@ export class FileSystemService {
             return null;
         }
     }
+    /**
+     * Extracts text content from a PDF file with pagination support.
+     * @param buffer - PDF file buffer
+     * @param filePath - Path to the PDF file
+     * @param fileSize - Size of the file in bytes
+     * @param options - Read options including offset and limit
+     * @returns FileContent with extracted text
+     */
+    async extractPdfTextContent(buffer, filePath, fileSize, options) {
+        // Extract text with pagination
+        const result = await PdfExtractor.extractText(buffer, filePath, {
+            limit: options.limit,
+            offset: options.offset,
+        });
+        const { hasMore, metadata, pages } = result;
+        const totalPages = metadata.pageCount;
+        // Check if PDF has no extractable text
+        const hasText = pages.some((p) => p.text.trim().length > 0);
+        if (!hasText && pages.length > 0) {
+            // Return helpful message for scanned/image-only PDFs
+            const metaInfo = metadata.title ? ` Title: "${metadata.title}".` : '';
+            return {
+                content: '',
+                encoding: 'utf8',
+                formattedContent: `<file type="pdf" pages="${totalPages}">\n[PDF has no extractable text - likely scanned or image-only]${metaInfo}\n</file>`,
+                lines: 0,
+                message: `PDF has no extractable text (${totalPages} pages).${metaInfo} ` +
+                    "This PDF may be scanned or contain only images. Try reading with pdfMode='base64' for multimodal analysis.",
+                pdfMetadata: metadata,
+                pdfPages: pages,
+                size: fileSize,
+                totalLines: totalPages,
+                truncated: false,
+            };
+        }
+        // Calculate next offset for continuation
+        const startPage = options.offset ?? 1;
+        const pagesRead = pages.length;
+        const nextOffset = startPage + pagesRead;
+        // Format content with page separators
+        const formattedText = formatPdfContent(pages, metadata, hasMore, nextOffset);
+        // Build XML-wrapped formatted content
+        const formattedContent = `<file type="pdf" pages="${totalPages}">\n${formattedText}\n</file>`;
+        // Build message
+        let message;
+        if (pagesRead === 0) {
+            message = `PDF has ${totalPages} pages. Requested offset ${startPage} is beyond the last page.`;
+        }
+        else if (hasMore) {
+            const endPage = startPage + pagesRead - 1;
+            const remainingPages = totalPages - endPage;
+            message =
+                `Read pages ${startPage}-${endPage}. ` +
+                    `${remainingPages} more pages available. Must set offset=${nextOffset} to continue reading.`;
+        }
+        else {
+            message = `End of PDF - read ${pagesRead} pages (${totalPages} total).`;
+        }
+        // Generate preview (first page text, truncated)
+        const previewText = pages[0]?.text ?? '';
+        const previewLines = previewText.split('\n').slice(0, PREVIEW_LINES);
+        const preview = previewLines.join('\n');
+        return {
+            content: pages.map((p) => p.text).join('\n\n'),
+            encoding: 'utf8',
+            formattedContent,
+            lines: pagesRead,
+            message,
+            pdfMetadata: metadata,
+            pdfPages: pages,
+            preview,
+            size: fileSize,
+            totalLines: totalPages,
+            truncated: hasMore,
+        };
+    }
     /**
      * Checks if a command is available in the system's PATH.
      */

package/dist/infra/cipher/file-system/pdf-extractor.d.ts

@@ -0,0 +1,100 @@
+import type { PdfMetadata, PdfPageContent } from '../../../core/domain/cipher/file-system/types.js';
+/**
+ * Options for PDF text extraction.
+ */
+export interface PdfExtractOptions {
+    /** Maximum number of pages to extract (default: 100, max: 200) */
+    limit?: number;
+    /** Starting page number (1-based, default: 1) */
+    offset?: number;
+}
+/**
+ * Result of PDF text extraction.
+ */
+export interface PdfExtractResult {
+    /** Whether there are more pages available after this extraction */
+    hasMore: boolean;
+    /** PDF metadata (page count, title, author, etc.) */
+    metadata: PdfMetadata;
+    /** Extracted page contents */
+    pages: PdfPageContent[];
+}
+/**
+ * PDF text extraction and metadata extraction utility.
+ * Provides page-by-page extraction with pagination support.
+ *
+ * Features:
+ * - Magic byte validation
+ * - Fast metadata-only extraction
+ * - Page-by-page text extraction with offset/limit
+ * - Default: 100 pages, max: 200 pages per extraction
+ */
+export declare class PdfExtractor {
+    /**
+     * Extracts metadata from a PDF buffer without extracting text.
+     * This is a fast path when you only need page count, title, author, etc.
+     *
+     * @param buffer - PDF file buffer
+     * @param filePath - Path to the PDF file (for error messages)
+     * @returns PDF metadata
+     */
+    static extractMetadata(buffer: Buffer, filePath: string): Promise<PdfMetadata>;
+    /**
+     * Extracts text from a PDF buffer with pagination support.
+     *
+     * @param buffer - PDF file buffer
+     * @param filePath - Path to the PDF file (for error messages)
+     * @param options - Extraction options (offset, limit)
+     * @returns Extraction result with pages, metadata, and continuation info
+     */
+    static extractText(buffer: Buffer, filePath: string, options?: PdfExtractOptions): Promise<PdfExtractResult>;
+    /**
+     * Checks if a buffer contains valid PDF magic bytes.
+     * @param buffer - Buffer to check
+     * @returns true if buffer starts with %PDF-
+     */
+    static isValidPdf(buffer: Buffer): boolean;
+    /**
+     * Builds PdfMetadata from unpdf meta info object.
+     * @param pageCount - Total number of pages
+     * @param info - Optional info object from unpdf getMeta
+     * @returns PdfMetadata object
+     */
+    private static buildMetadataFromInfo;
+    /**
+     * Extracts text from specific pages of a PDF document.
+     * Uses PDF.js page-level API for efficient extraction of page ranges.
+     *
+     * @param pdf - PDF document proxy from unpdf
+     * @param startPage - Starting page number (1-based)
+     * @param endPage - Ending page number (1-based, inclusive)
+     * @returns Array of PdfPageContent with extracted text
+     */
+    private static extractPagesFromDocument;
+    /**
+     * Extracts a meaningful error message from an unknown error.
+     */
+    private static getExtractionErrorMessage;
+    /**
+     * Parses PDF date string format (D:YYYYMMDDHHmmSS) to Date object.
+     * @param dateStr - PDF date string
+     * @returns Parsed Date or undefined if invalid
+     */
+    private static parsePdfDate;
+    /**
+     * Wraps extraction errors with appropriate PdfExtractionError.
+     * @param error - The caught error
+     * @param filePath - Path to the PDF file
+     * @returns PdfExtractionError with appropriate message
+     */
+    private static wrapExtractionError;
+}
+/**
+ * Formats extracted PDF pages into a readable string with page separators.
+ * @param pages - Array of extracted page contents
+ * @param metadata - PDF metadata
+ * @param hasMore - Whether there are more pages
+ * @param nextOffset - Next offset for continuation (if hasMore is true)
+ * @returns Formatted string with page separators
+ */
+export declare function formatPdfContent(pages: PdfPageContent[], metadata: PdfMetadata, hasMore: boolean, nextOffset: number): string;