conpub 0.1.4

Agent-first CLI for publishing local knowledge files to Confluence Cloud
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

use crate::domain::canonical_tags;
use crate::support::*;
use std::fs;
use std::path::Path;
use typub_core::ContentFormat;

pub(crate) struct InspectedDocument {
    pub(crate) title: String,
    pub(crate) tags: Vec<String>,
}

pub(crate) fn inspect_document_source(root: &Path, path: &Path) -> AppResult<InspectedDocument> {
    let text = fs::read_to_string(path).map_err(|err| {
        AppError::new(
            "FILE_READ_ERROR",
            format!("failed to read {}: {err}", path.display()),
        )
    })?;
    let format = match path.extension().and_then(|extension| extension.to_str()) {
        Some("md") => ContentFormat::Markdown,
        Some("typ") => ContentFormat::Typst,
        _ => {
            return Err(AppError::new(
                "UNSUPPORTED_DOCUMENT",
                format!("unsupported document source: {}", path.display()),
            ));
        }
    };

    match typub_engine::inspect_source(root, path, format) {
        Ok(inspection) => Ok(InspectedDocument {
            title: inspection
                .title
                .unwrap_or_else(|| fallback_title_from_path(path)),
            tags: canonical_tags(
                inspection.metadata.tags.unwrap_or_default(),
                &format!("source {}", path.display()),
            )?,
        }),
        Err(err) if declares_source_metadata(&text, format) => Err(AppError::new(
            "SOURCE_METADATA_ERROR",
            format!(
                "failed to inspect source metadata in {}: {err:#}",
                path.display()
            ),
        )),
        Err(_) => Ok(InspectedDocument {
            title: fallback_title_from_path(path),
            tags: Vec::new(),
        }),
    }
}

fn declares_source_metadata(text: &str, format: ContentFormat) -> bool {
    match format {
        ContentFormat::Markdown => has_markdown_frontmatter(text),
        ContentFormat::Typst => text.contains("<typub-meta>"),
    }
}

fn has_markdown_frontmatter(text: &str) -> bool {
    let text = text.strip_prefix('\u{feff}').unwrap_or(text);
    let mut lines = text.lines();
    if lines.next().map(trim_frontmatter_line) != Some("---") {
        return false;
    }
    if lines
        .next()
        .is_none_or(|line| trim_frontmatter_line(line).is_empty())
    {
        return false;
    }
    lines.any(|line| matches!(trim_frontmatter_line(line), "---" | "..."))
}

fn trim_frontmatter_line(line: &str) -> &str {
    line.trim_end_matches([' ', '\t', '\r'])
}

fn fallback_title_from_path(path: &Path) -> String {
    path.file_stem()
        .and_then(|stem| stem.to_str())
        .unwrap_or("untitled")
        .to_string()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn markdown_frontmatter_requires_a_complete_nonempty_block() {
        assert!(has_markdown_frontmatter(
            "---\ntags: [rust]\n---\n# Title\n"
        ));
        assert!(has_markdown_frontmatter(
            "---\ntags: [rust]\n...\n# Title\n"
        ));
        assert!(!has_markdown_frontmatter("---\n\nParagraph\n"));
        assert!(!has_markdown_frontmatter("---\nHorizontal rule only\n"));
    }
}