Files
marqdo/src/load.rs
T
cflmyandCursor 3a7e11c995 Add ext/agent layout framework, ext CLI, and docs catch-up.
Ship ABI agent plugin helpers, marqdo ext list/add/remove, and document the agent development roadmap (compose LLM, match/assign).

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-08-06 13:31:25 +08:00

179 lines
5.5 KiB
Rust

//! Load `.mq.md` files and merge frontmatter imports.
use std::collections::HashSet;
use std::env;
use std::path::{Path, PathBuf};
use anyhow::{bail, Context, Result};
use crate::ast::{Function, Module};
use crate::diagnostics::Diagnostic;
use crate::parse::parse_source;
/// Load `path` and recursively merge imported modules' top-level functions.
pub fn load_module(path: &Path) -> Result<Module> {
let mut visited = HashSet::new();
load_module_inner(path, &mut visited)
}
fn load_module_inner(path: &Path, visited: &mut HashSet<PathBuf>) -> Result<Module> {
let canon = path
.canonicalize()
.unwrap_or_else(|_| path.to_path_buf());
if !visited.insert(canon.clone()) {
bail!("circular import involving {}", path.display());
}
let source = std::fs::read_to_string(path)
.with_context(|| format!("failed to read {}", path.display()))?;
let mut module = parse_source(&source).map_err(|e| attach_path(path, e))?;
let base = path.parent().unwrap_or_else(|| Path::new("."));
let imports = module.imports.clone();
for rel in imports {
let dep_path = resolve_import(base, &rel)?;
let dep = load_module_inner(&dep_path, visited)?;
for fun in dep.functions {
merge_top_level(&mut module.functions, fun);
}
}
Ok(module)
}
/// Resolve an import path: relative to the importer first; `lib/…` / `std/…`
/// and `ext/…` also search official roots (`MARQDO_LIB` / `MARQDO_EXT`, cwd, near the binary).
pub fn resolve_import(from_dir: &Path, rel: &str) -> Result<PathBuf> {
let rel = rel.replace('\\', "/");
let direct = from_dir.join(&rel);
if direct.is_file() {
return Ok(direct);
}
let normalized = if let Some(rest) = rel.strip_prefix("std/") {
format!("lib/{rest}")
} else {
rel.clone()
};
if let Some(remainder) = normalized.strip_prefix("lib/") {
for root in lib_search_roots() {
let as_lib_dir = root.join(remainder);
if as_lib_dir.is_file() {
return Ok(as_lib_dir);
}
let as_repo_root = root.join("lib").join(remainder);
if as_repo_root.is_file() {
return Ok(as_repo_root);
}
}
bail!(
"cannot resolve library import `{rel}` (set MARQDO_LIB or keep a lib/ next to the project)"
);
}
if let Some(remainder) = normalized.strip_prefix("ext/") {
for root in ext_search_roots() {
let as_ext_dir = root.join(remainder);
if as_ext_dir.is_file() {
return Ok(as_ext_dir);
}
let as_repo_root = root.join("ext").join(remainder);
if as_repo_root.is_file() {
return Ok(as_repo_root);
}
}
bail!(
"cannot resolve extension import `{rel}` (set MARQDO_EXT or keep an ext/ next to the project)"
);
}
Ok(direct)
}
fn lib_search_roots() -> Vec<PathBuf> {
let mut roots = Vec::new();
if let Ok(h) = env::var("MARQDO_LIB") {
roots.push(PathBuf::from(h));
}
if let Ok(cwd) = env::current_dir() {
roots.push(cwd.join("lib"));
roots.push(cwd);
}
if let Ok(exe) = env::current_exe() {
if let Some(dir) = exe.parent() {
roots.push(dir.join("lib"));
roots.push(dir.join("../lib"));
roots.push(dir.join("../../lib"));
roots.push(dir.join("../../../lib"));
}
}
roots
}
fn ext_search_roots() -> Vec<PathBuf> {
let mut roots = Vec::new();
if let Ok(h) = env::var("MARQDO_EXT") {
roots.push(PathBuf::from(h));
}
// Official installer default (`marqdo ext add`)
roots.push(crate::ext_cli::default_user_ext_dir());
if let Ok(cwd) = env::current_dir() {
roots.push(cwd.join("ext"));
roots.push(cwd);
}
if let Ok(exe) = env::current_exe() {
if let Some(dir) = exe.parent() {
roots.push(dir.join("ext"));
roots.push(dir.join("../ext"));
roots.push(dir.join("../../ext"));
roots.push(dir.join("../../../ext"));
}
}
roots
}
fn attach_path(path: &Path, err: anyhow::Error) -> anyhow::Error {
if let Some(d) = err.downcast_ref::<Diagnostic>() {
if d.path.is_none() {
return Diagnostic::at(path, d.span, d.message.clone()).into();
}
return err;
}
let msg = err.to_string();
if let Some((loc, rest)) = msg.split_once(": ") {
if let Some((line_s, col_s)) = loc.split_once(':') {
if let (Ok(line), Ok(col)) = (line_s.parse::<u32>(), col_s.parse::<u32>()) {
return Diagnostic::at(path, crate::diagnostics::Span::new(line, col), rest).into();
}
}
}
err.context(format!("in {}", path.display()))
}
fn merge_top_level(into: &mut Vec<Function>, fun: Function) {
if let Some(existing) = into.iter_mut().find(|f| f.name == fun.name) {
*existing = fun;
} else {
into.push(fun);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn resolve_lib_from_cwd() {
let cwd = env::current_dir().unwrap();
let lib_text = cwd.join("lib").join("text.mq.md");
if !lib_text.is_file() {
return;
}
let p = resolve_import(Path::new("tests/keywords"), "lib/text.mq.md").unwrap();
assert!(p.ends_with("text.mq.md"));
let p2 = resolve_import(Path::new("tests/keywords"), "std/text.mq.md").unwrap();
assert!(p2.ends_with("text.mq.md"));
}
}