marque-extract 0.2.1

Document text and metadata extraction via Kreuzberg (75+ formats, OCR)
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

// SPDX-FileCopyrightText: 2026 Knitli Inc.
//
// SPDX-License-Identifier: LicenseRef-MarqueLicense-1.0

//! Document text extraction with streaming support.
//!
//! TODO: wire Kreuzberg once crate dependency is confirmed.
//! Current implementation is a stub that reads raw text files only.

use crate::metadata::MetadataReport;
use std::path::Path;
use thiserror::Error;

#[derive(Debug, Error)]
pub enum ExtractError {
    #[error("unsupported format: {0}")]
    UnsupportedFormat(String),

    #[error("extraction failed: {0}")]
    ExtractionFailed(String),

    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),
}

/// Options controlling extraction behavior.
#[derive(Debug, Clone, Default)]
pub struct ExtractionOptions {
    /// Extract and report document metadata.
    pub extract_metadata: bool,
    /// Remove metadata from the output document (creates a sanitized copy).
    pub strip_metadata: bool,
    /// Attempt OCR on image-based pages (requires OCR backend).
    pub ocr: bool,
}

/// Result of document extraction.
#[derive(Debug)]
pub struct ExtractedDocument {
    /// Extracted text content, UTF-8.
    pub text: Vec<u8>,
    /// Metadata report (populated if `extract_metadata` was set).
    pub metadata: Option<MetadataReport>,
    /// Original format detected.
    pub format: DetectedFormat,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DetectedFormat {
    PlainText,
    Docx,
    Pdf,
    Html,
    Xlsx,
    Pptx,
    Email,
    Unknown(String),
}

/// Stateless document extractor.
pub struct Extractor;

impl Extractor {
    /// Extract text (and optionally metadata) from a file.
    pub async fn extract(
        path: &Path,
        _opts: ExtractionOptions,
    ) -> Result<ExtractedDocument, ExtractError> {
        // TODO: delegate to Kreuzberg for full format support.
        // Stub: read raw bytes and return as-is for plain text.
        let ext = path
            .extension()
            .and_then(|e| e.to_str())
            .unwrap_or("")
            .to_lowercase();

        match ext.as_str() {
            "txt" | "text" => {
                let text = tokio::fs::read(path).await?;
                Ok(ExtractedDocument {
                    text,
                    metadata: None,
                    format: DetectedFormat::PlainText,
                })
            }
            "docx" => Err(ExtractError::UnsupportedFormat(
                "docx extraction requires Kreuzberg integration (TODO)".into(),
            )),
            "pdf" => Err(ExtractError::UnsupportedFormat(
                "pdf extraction requires Kreuzberg integration (TODO)".into(),
            )),
            other => Err(ExtractError::UnsupportedFormat(other.to_owned())),
        }
    }

    /// Extract from an in-memory buffer with an explicit format hint.
    pub fn extract_bytes(
        data: &[u8],
        format: DetectedFormat,
        _opts: ExtractionOptions,
    ) -> Result<ExtractedDocument, ExtractError> {
        match format {
            DetectedFormat::PlainText => Ok(ExtractedDocument {
                text: data.to_vec(),
                metadata: None,
                format: DetectedFormat::PlainText,
            }),
            _ => Err(ExtractError::UnsupportedFormat(
                "non-text extraction requires Kreuzberg integration (TODO)".into(),
            )),
        }
    }
}