cml-rs 0.4.0

Content Markup Language (CML) v0.2 parser, generator, validator, and embedding store for structured documents
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
114
115
116

//! # CML (Content Markup Language)
//!
//! CML is a semantic markup language designed for long-term interpretable content storage.
//! It separates content from presentation and enables efficient vector-based semantic search.
//!
//! ## CML Structure
//!
//! ```xml
//! <cml profile="core" version="0.2" encoding="utf-8">
//!   <header>
//!     <title>Document Title</title>
//!     <author role="author">Author Name</author>
//!     <date type="created" when="2025-12-22"/>
//!   </header>
//!   <body>
//!     <section id="intro">
//!       <heading size="1">Introduction</heading>
//!       <paragraph>Content here with <em>inline elements</em>.</paragraph>
//!     </section>
//!   </body>
//!   <footer>
//!   </footer>
//! </cml>
//! ```
//!
//! ## Features
//!
//! - **Profile-based schemas**: Domain-specific document structures (law, code, edu)
//! - **Pathless references**: `namespace:identifier` format (e.g., `president:47`)
//! - **Active documents**: Currency conversion, date localization (future)
//! - **Validation**: ID uniqueness, reference integrity, structural correctness
//!
//! ## Usage
//!
//! ```rust
//! use cml_rs::{CmlParser, CmlGenerator, CmlValidator};
//!
//! // Parse CML
//! let xml = r#"<cml profile="core" version="0.2" encoding="utf-8">
//!   <header><title>Test</title></header>
//!   <body><paragraph>Hello!</paragraph></body>
//!   <footer></footer>
//! </cml>"#;
//!
//! let doc = CmlParser::parse_str(xml)?;
//!
//! // Validate
//! CmlValidator::validate(&doc)?;
//!
//! // Generate
//! let xml = CmlGenerator::generate(&doc)?;
//! # Ok::<(), cml_rs::CmlError>(())
//! ```

// Core CML modules
pub mod generator;
pub mod parser;
pub mod profile;
pub mod types;
pub mod validator;

// Utilities
// TODO: Revisit chunker and embedding_store after the semantic compiler move.
pub mod chunker;
pub mod embedding_store;
pub mod id_generator;

// Re-export primary types and functions
pub use generator::CmlGenerator;
pub use parser::CmlParser;
pub use profile::{Profile, ProfileRegistry, ResolvedProfile};
pub use types::*;
pub use validator::CmlValidator;

// Re-export utilities
// TODO: Revisit chunker and embedding_store after the semantic compiler move.
pub use chunker::{Chunk, CmlChunker, CHUNK_OVERLAP_TOKENS, MAX_CHUNK_TOKENS};
pub use embedding_store::{ChunkMatch, EmbeddingStore, MatchType, EMBEDDING_DIM};
pub use id_generator::{BookstackIdGenerator, CodeIdGenerator, ElementId, LegalIdGenerator};

/// Result type for CML operations
pub type Result<T> = std::result::Result<T, CmlError>;

/// Errors that can occur during CML processing
#[derive(Debug, thiserror::Error)]
pub enum CmlError {
    #[error("XML parsing error: {0}")]
    XmlError(#[from] quick_xml::Error),

    #[error("XML attribute error: {0}")]
    AttrError(#[from] quick_xml::events::attributes::AttrError),

    #[error("Invalid document structure: {0}")]
    InvalidStructure(String),

    #[error("Missing required attribute: {0}")]
    MissingAttribute(String),

    #[error("Invalid attribute value: {0}")]
    InvalidAttribute(String),

    #[error("Schema validation failed: {0}")]
    ValidationError(String),

    #[error("Duplicate ID: {0}")]
    DuplicateId(String),

    #[error("Reference not found: {0}")]
    ReferenceNotFound(String),

    #[error("IO error: {0}")]
    IoError(#[from] std::io::Error),

    #[error("UTF-8 error: {0}")]
    Utf8Error(#[from] std::string::FromUtf8Error),
}