lc-cli 0.1.3

LLM Client - A fast Rust-based LLM CLI tool with provider management and chat sessions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use super::FileReader;
use anyhow::{Context, Result};
use std::io::Read;

#[cfg(feature = "pdf")]
extern crate pdf_extract;

pub struct PdfReader;

impl PdfReader {
    pub fn new() -> Self {
        Self
    }

    /// Internal method to extract text from PDF bytes with comprehensive error handling
    fn extract_text_from_bytes_internal(&self, bytes: &[u8]) -> Result<String> {
        #[cfg(feature = "pdf")]
        {
            // Attempt to extract text using pdf-extract
            match pdf_extract::extract_text_from_mem(bytes) {
                Ok(text) => {
                    // Check if the extracted text is mostly empty or contains only whitespace
                    let cleaned_text = text.trim();
                    if cleaned_text.is_empty() {
                        // This might be a bitmap-only PDF
                        return Ok("[image page]".to_string());
                    }

                    // Preserve page breaks by converting form feed characters
                    let formatted_text = text.replace('\x0C', "\u{000C}");

                    // Ensure UTF-8 encoding
                    Ok(formatted_text)
                }
                Err(e) => {
                    // Check if this might be an encrypted PDF
                    let error_msg = e.to_string().to_lowercase();
                    if error_msg.contains("encrypt")
                        || error_msg.contains("password")
                        || error_msg.contains("security")
                    {
                        // Try passwordless decryption attempt (pdf-extract handles this internally)
                        // If it fails, return appropriate error
                        Err(anyhow::anyhow!(
                            "PDF appears to be encrypted and requires a password for text extraction. \
                            Error: {}", e
                        ))
                    } else {
                        // Check if this might be a bitmap-only PDF
                        if error_msg.contains("no text")
                            || error_msg.contains("image")
                            || error_msg.contains("scan")
                        {
                            Ok("[image page]".to_string())
                        } else {
                            Err(anyhow::anyhow!("Failed to extract text from PDF: {}", e))
                        }
                    }
                }
            }
        }
        #[cfg(not(feature = "pdf"))]
        {
            let _ = bytes; // Suppress unused parameter warning
            Err(anyhow::anyhow!(
                "PDF support is not enabled. Please compile with the 'pdf' feature flag to enable PDF processing."
            ))
        }
    }
}

impl FileReader for PdfReader {
    fn read_as_text(&self, file_path: &str) -> Result<String> {
        let bytes = std::fs::read(file_path)
            .with_context(|| format!("Failed to read PDF file: {}", file_path))?;

        self.read_as_text_from_bytes(&bytes)
            .with_context(|| format!("Failed to extract text from PDF file: {}", file_path))
    }

    fn read_as_text_from_bytes(&self, bytes: &[u8]) -> Result<String> {
        self.extract_text_from_bytes_internal(bytes)
    }

    fn read_as_text_from_reader(&self, mut reader: Box<dyn Read>) -> Result<String> {
        let mut bytes = Vec::new();
        reader
            .read_to_end(&mut bytes)
            .with_context(|| "Failed to read bytes from reader")?;

        self.read_as_text_from_bytes(&bytes)
    }

    fn can_handle(&self, extension: &str) -> bool {
        extension.to_lowercase() == "pdf"
    }
}