robinpath_modules/modules/

markdown_mod.rs

use robinpath::{RobinPath, Value};

pub fn register(rp: &mut RobinPath) {
    rp.register_builtin("markdown.toHtml", |args, _| {
        let md = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        Ok(Value::String(markdown_to_html(&md)))
    });

    rp.register_builtin("markdown.extractHeadings", |args, _| {
        let md = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let re = regex::Regex::new(r"^(#{1,6})\s+(.+)$").unwrap();
        let headings: Vec<Value> = md
            .lines()
            .filter_map(|line| {
                re.captures(line).map(|caps| {
                    let mut obj = indexmap::IndexMap::new();
                    obj.insert("level".to_string(), Value::Number(caps[1].len() as f64));
                    obj.insert("text".to_string(), Value::String(caps[2].trim().to_string()));
                    Value::Object(obj)
                })
            })
            .collect();
        Ok(Value::Array(headings))
    });

    rp.register_builtin("markdown.extractLinks", |args, _| {
        let md = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let re = regex::Regex::new(r"\[([^\]]*)\]\(([^)]+)\)").unwrap();
        let links: Vec<Value> = re
            .captures_iter(&md)
            .map(|caps| {
                let mut obj = indexmap::IndexMap::new();
                obj.insert("text".to_string(), Value::String(caps[1].to_string()));
                obj.insert("url".to_string(), Value::String(caps[2].to_string()));
                Value::Object(obj)
            })
            .collect();
        Ok(Value::Array(links))
    });

    rp.register_builtin("markdown.extractImages", |args, _| {
        let md = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let re = regex::Regex::new(r"!\[([^\]]*)\]\(([^)]+)\)").unwrap();
        let images: Vec<Value> = re
            .captures_iter(&md)
            .map(|caps| {
                let mut obj = indexmap::IndexMap::new();
                obj.insert("alt".to_string(), Value::String(caps[1].to_string()));
                obj.insert("src".to_string(), Value::String(caps[2].to_string()));
                Value::Object(obj)
            })
            .collect();
        Ok(Value::Array(images))
    });

    rp.register_builtin("markdown.extractCodeBlocks", |args, _| {
        let md = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let re = regex::Regex::new(r"(?ms)```(\w*)\n(.*?)```").unwrap();
        let blocks: Vec<Value> = re
            .captures_iter(&md)
            .map(|caps| {
                let mut obj = indexmap::IndexMap::new();
                obj.insert("language".to_string(), Value::String(caps[1].to_string()));
                obj.insert("code".to_string(), Value::String(caps[2].to_string()));
                Value::Object(obj)
            })
            .collect();
        Ok(Value::Array(blocks))
    });

    rp.register_builtin("markdown.stripMarkdown", |args, _| {
        let md = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let mut s = md;
        // Remove code blocks
        let code_re = regex::Regex::new(r"(?ms)```.*?```").unwrap();
        s = code_re.replace_all(&s, "").to_string();
        // Remove inline code
        let inline_re = regex::Regex::new(r"`[^`]+`").unwrap();
        s = inline_re.replace_all(&s, "").to_string();
        // Remove images
        let img_re = regex::Regex::new(r"!\[([^\]]*)\]\([^)]+\)").unwrap();
        s = img_re.replace_all(&s, "$1").to_string();
        // Remove links but keep text
        let link_re = regex::Regex::new(r"\[([^\]]*)\]\([^)]+\)").unwrap();
        s = link_re.replace_all(&s, "$1").to_string();
        // Remove headings markers
        let h_re = regex::Regex::new(r"^#{1,6}\s+").unwrap();
        s = s.lines().map(|l| h_re.replace(l, "").to_string()).collect::<Vec<_>>().join("\n");
        // Remove bold/italic
        let bold_re = regex::Regex::new(r"\*{1,3}([^*]+)\*{1,3}").unwrap();
        s = bold_re.replace_all(&s, "$1").to_string();
        let under_re = regex::Regex::new(r"_{1,3}([^_]+)_{1,3}").unwrap();
        s = under_re.replace_all(&s, "$1").to_string();
        // Remove strikethrough
        let strike_re = regex::Regex::new(r"~~([^~]+)~~").unwrap();
        s = strike_re.replace_all(&s, "$1").to_string();
        Ok(Value::String(s.trim().to_string()))
    });

    rp.register_builtin("markdown.extractTodos", |args, _| {
        let md = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let re = regex::Regex::new(r"^-\s+\[([ xX])\]\s+(.+)$").unwrap();
        let todos: Vec<Value> = md
            .lines()
            .filter_map(|line| {
                re.captures(line.trim()).map(|caps| {
                    let mut obj = indexmap::IndexMap::new();
                    obj.insert("text".to_string(), Value::String(caps[2].to_string()));
                    obj.insert("checked".to_string(), Value::Bool(&caps[1] != " "));
                    Value::Object(obj)
                })
            })
            .collect();
        Ok(Value::Array(todos))
    });

    rp.register_builtin("markdown.tableToArray", |args, _| {
        let md = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let lines: Vec<&str> = md.lines().filter(|l| l.contains('|')).collect();
        if lines.len() < 2 {
            return Ok(Value::Array(vec![]));
        }
        let headers: Vec<String> = lines[0]
            .split('|')
            .map(|s| s.trim().to_string())
            .filter(|s| !s.is_empty())
            .collect();
        // Skip separator line (line 1)
        let rows: Vec<Value> = lines[2..]
            .iter()
            .map(|line| {
                let cells: Vec<String> = line
                    .split('|')
                    .map(|s| s.trim().to_string())
                    .filter(|s| !s.is_empty())
                    .collect();
                let mut obj = indexmap::IndexMap::new();
                for (i, header) in headers.iter().enumerate() {
                    obj.insert(
                        header.clone(),
                        Value::String(cells.get(i).cloned().unwrap_or_default()),
                    );
                }
                Value::Object(obj)
            })
            .collect();
        Ok(Value::Array(rows))
    });

    rp.register_builtin("markdown.wordCount", |args, _| {
        let md = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        // Strip markdown first
        let code_re = regex::Regex::new(r"(?ms)```.*?```").unwrap();
        let cleaned = code_re.replace_all(&md, "");
        let tag_re = regex::Regex::new(r"[#*_`~\[\]()!]").unwrap();
        let stripped = tag_re.replace_all(&cleaned, "");
        let count = stripped.split_whitespace().count();
        Ok(Value::Number(count as f64))
    });
}

fn markdown_to_html(md: &str) -> String {
    let mut html = String::new();
    let mut in_code_block = false;

    for line in md.lines() {
        if line.starts_with("```") {
            if in_code_block {
                html.push_str("</code></pre>\n");
                in_code_block = false;
            } else {
                let lang = line.trim_start_matches('`').trim();
                if lang.is_empty() {
                    html.push_str("<pre><code>");
                } else {
                    html.push_str(&format!("<pre><code class=\"language-{}\">", lang));
                }
                in_code_block = true;
            }
            continue;
        }
        if in_code_block {
            html.push_str(&escape_html_basic(line));
            html.push('\n');
            continue;
        }

        let mut processed = line.to_string();

        // Headings
        if let Some(caps) = regex::Regex::new(r"^(#{1,6})\s+(.+)$").unwrap().captures(&processed) {
            let level = caps[1].len();
            html.push_str(&format!("<h{}>{}</h{}>\n", level, &caps[2], level));
            continue;
        }

        // Bold
        let bold_re = regex::Regex::new(r"\*\*([^*]+)\*\*").unwrap();
        processed = bold_re.replace_all(&processed, "<strong>$1</strong>").to_string();
        // Italic
        let italic_re = regex::Regex::new(r"\*([^*]+)\*").unwrap();
        processed = italic_re.replace_all(&processed, "<em>$1</em>").to_string();
        // Inline code
        let code_re = regex::Regex::new(r"`([^`]+)`").unwrap();
        processed = code_re.replace_all(&processed, "<code>$1</code>").to_string();
        // Links
        let link_re = regex::Regex::new(r"\[([^\]]+)\]\(([^)]+)\)").unwrap();
        processed = link_re.replace_all(&processed, "<a href=\"$2\">$1</a>").to_string();
        // Images
        let img_re = regex::Regex::new(r"!\[([^\]]*)\]\(([^)]+)\)").unwrap();
        processed = img_re.replace_all(&processed, "<img src=\"$2\" alt=\"$1\">").to_string();

        if processed.trim().is_empty() {
            html.push('\n');
        } else {
            html.push_str(&format!("<p>{}</p>\n", processed));
        }
    }
    html.trim().to_string()
}

fn escape_html_basic(s: &str) -> String {
    s.replace('&', "&amp;")
        .replace('<', "&lt;")
        .replace('>', "&gt;")
}