Compose ext/llm, add ABI match_skill/bump_load, map-valued GFM tables, and agent-assign gold coverage. Co-authored-by: Cursor <cursoragent@cursor.com>
575 lines
16 KiB
Rust
575 lines
16 KiB
Rust
//! Agent layout plugin (C ABI v1): find_root, ensure_layout, probe, scaffold.
|
|
|
|
use std::ffi::{CStr, CString};
|
|
use std::os::raw::{c_char, c_int, c_void};
|
|
use std::path::{Component, Path, PathBuf};
|
|
use std::ptr;
|
|
|
|
const ABI_VERSION: u32 = 1;
|
|
const DEFAULT_MARKERS: &str = "agents,runbooks,marqdo.agent.json";
|
|
const LAYOUT_DIRS: &[&str] = &["agents", "runbooks", "templates", "reports"];
|
|
|
|
type PluginFn = unsafe extern "C" fn(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int;
|
|
|
|
#[repr(C)]
|
|
pub struct MarqdoHostApi {
|
|
pub userdata: *mut c_void,
|
|
pub register_fn: Option<
|
|
unsafe extern "C" fn(
|
|
userdata: *mut c_void,
|
|
name: *const c_char,
|
|
params: *const c_char,
|
|
fn_ptr: PluginFn,
|
|
) -> c_int,
|
|
>,
|
|
pub alloc: Option<unsafe extern "C" fn(n: usize) -> *mut c_void>,
|
|
pub free: Option<unsafe extern "C" fn(p: *mut c_void)>,
|
|
}
|
|
|
|
static mut HOST_FREE: Option<unsafe extern "C" fn(*mut c_void)> = None;
|
|
static mut HOST_ALLOC: Option<unsafe extern "C" fn(usize) -> *mut c_void> = None;
|
|
|
|
unsafe fn host_strdup(s: &str) -> *mut c_char {
|
|
let alloc = HOST_ALLOC.expect("host alloc");
|
|
let bytes = s.as_bytes();
|
|
let p = alloc(bytes.len() + 1) as *mut u8;
|
|
if p.is_null() {
|
|
return ptr::null_mut();
|
|
}
|
|
std::ptr::copy_nonoverlapping(bytes.as_ptr(), p, bytes.len());
|
|
*p.add(bytes.len()) = 0;
|
|
p as *mut c_char
|
|
}
|
|
|
|
fn set_out(out: *mut *mut c_char, s: &str) {
|
|
if out.is_null() {
|
|
return;
|
|
}
|
|
unsafe {
|
|
*out = host_strdup(s);
|
|
}
|
|
}
|
|
|
|
fn set_err(err: *mut *mut c_char, s: &str) {
|
|
if err.is_null() {
|
|
return;
|
|
}
|
|
unsafe {
|
|
*err = host_strdup(s);
|
|
}
|
|
}
|
|
|
|
fn parse_args(args_json: *const c_char) -> Result<serde_json::Value, String> {
|
|
if args_json.is_null() {
|
|
return Err("null args".into());
|
|
}
|
|
let s = unsafe { CStr::from_ptr(args_json) }
|
|
.to_str()
|
|
.map_err(|_| "args not utf-8".to_string())?;
|
|
serde_json::from_str(s).map_err(|e| e.to_string())
|
|
}
|
|
|
|
fn arg_str<'a>(v: &'a serde_json::Value, key: &str) -> Result<&'a str, String> {
|
|
v.get(key)
|
|
.and_then(|x| x.as_str())
|
|
.ok_or_else(|| format!("missing text `{key}`"))
|
|
}
|
|
|
|
fn has_parent_escape(rel: &Path) -> bool {
|
|
rel.components().any(|c| matches!(c, Component::ParentDir))
|
|
}
|
|
|
|
fn find_root(start: &str, markers: &str) -> Result<PathBuf, String> {
|
|
let markers: Vec<&str> = markers
|
|
.split(',')
|
|
.map(|s| s.trim())
|
|
.filter(|s| !s.is_empty())
|
|
.collect();
|
|
if markers.is_empty() {
|
|
return Err("empty markers".into());
|
|
}
|
|
let mut cur = PathBuf::from(start);
|
|
if cur.as_os_str().is_empty() {
|
|
cur = std::env::current_dir().map_err(|e| e.to_string())?;
|
|
}
|
|
if !cur.exists() {
|
|
return Err(format!("start path missing: {}", cur.display()));
|
|
}
|
|
let mut cur = std::fs::canonicalize(&cur).map_err(|e| e.to_string())?;
|
|
loop {
|
|
for m in &markers {
|
|
let p = cur.join(m);
|
|
let ok = if m.contains('.') {
|
|
p.is_file()
|
|
} else {
|
|
p.is_dir()
|
|
};
|
|
if ok {
|
|
return Ok(cur);
|
|
}
|
|
}
|
|
if !cur.pop() {
|
|
break;
|
|
}
|
|
}
|
|
Err("agent project root not found".into())
|
|
}
|
|
|
|
fn ensure_layout(root: &Path) -> Result<i64, String> {
|
|
let root = std::fs::canonicalize(root).map_err(|e| e.to_string())?;
|
|
let mut created = 0i64;
|
|
for d in LAYOUT_DIRS {
|
|
let p = root.join(d);
|
|
if !p.exists() {
|
|
std::fs::create_dir_all(&p).map_err(|e| e.to_string())?;
|
|
created += 1;
|
|
} else if !p.is_dir() {
|
|
return Err(format!("{} exists and is not a directory", p.display()));
|
|
}
|
|
}
|
|
Ok(created)
|
|
}
|
|
|
|
fn probe(root: &Path) -> Result<serde_json::Value, String> {
|
|
let root = std::fs::canonicalize(root).map_err(|e| e.to_string())?;
|
|
let mut map = serde_json::Map::new();
|
|
map.insert(
|
|
"root".into(),
|
|
serde_json::Value::String(root.to_string_lossy().into_owned()),
|
|
);
|
|
for d in LAYOUT_DIRS {
|
|
let key = format!("has_{d}");
|
|
map.insert(key, serde_json::Value::Bool(root.join(d).is_dir()));
|
|
}
|
|
Ok(serde_json::Value::Object(map))
|
|
}
|
|
|
|
fn scaffold(root: &Path, name: &str, template: &str, dest: &str) -> Result<String, String> {
|
|
if name.is_empty() {
|
|
return Err("name is empty".into());
|
|
}
|
|
let root = std::fs::canonicalize(root).map_err(|e| e.to_string())?;
|
|
let tmpl_rel = Path::new(template);
|
|
let dest_rel = Path::new(dest);
|
|
if has_parent_escape(tmpl_rel) {
|
|
return Err("template path escapes project root".into());
|
|
}
|
|
if has_parent_escape(dest_rel) {
|
|
return Err("dest path escapes project root".into());
|
|
}
|
|
let tmpl_path = root.join(tmpl_rel);
|
|
if !tmpl_path.is_file() {
|
|
return Err(format!("template not found: {}", tmpl_path.display()));
|
|
}
|
|
let tmpl_can = std::fs::canonicalize(&tmpl_path).map_err(|e| e.to_string())?;
|
|
if !tmpl_can.starts_with(&root) {
|
|
return Err("template path escapes project root".into());
|
|
}
|
|
let dest_path = root.join(dest_rel);
|
|
if let Some(parent) = dest_path.parent() {
|
|
std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
|
|
let parent_can = std::fs::canonicalize(parent).map_err(|e| e.to_string())?;
|
|
if !parent_can.starts_with(&root) {
|
|
return Err("dest path escapes project root".into());
|
|
}
|
|
}
|
|
let body = std::fs::read_to_string(&tmpl_can).map_err(|e| e.to_string())?;
|
|
let body = body.replace("{{name}}", name);
|
|
std::fs::write(&dest_path, body).map_err(|e| e.to_string())?;
|
|
Ok(dest_path.to_string_lossy().into_owned())
|
|
}
|
|
|
|
fn map_get_str<'a>(m: &'a serde_json::Value, keys: &[&str]) -> Option<&'a str> {
|
|
let obj = m.as_object()?;
|
|
for k in keys {
|
|
if let Some(v) = obj.get(*k) {
|
|
if let Some(s) = v.as_str() {
|
|
return Some(s);
|
|
}
|
|
if let Some(n) = v.as_i64() {
|
|
// allow numeric fields to be read as display later
|
|
let _ = n;
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn map_get_i64(m: &serde_json::Value, keys: &[&str]) -> i64 {
|
|
let Some(obj) = m.as_object() else {
|
|
return i64::MAX;
|
|
};
|
|
for k in keys {
|
|
if let Some(v) = obj.get(*k) {
|
|
if let Some(n) = v.as_i64() {
|
|
return n;
|
|
}
|
|
if let Some(s) = v.as_str() {
|
|
if let Ok(n) = s.parse::<i64>() {
|
|
return n;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
i64::MAX
|
|
}
|
|
|
|
fn skills_text(m: &serde_json::Value) -> String {
|
|
map_get_str(m, &["技能", "skills", "skill"])
|
|
.unwrap_or("")
|
|
.to_string()
|
|
}
|
|
|
|
fn match_skill(skill: &str, members: &serde_json::Value) -> Result<serde_json::Value, String> {
|
|
let arr = members
|
|
.as_array()
|
|
.ok_or_else(|| "members must be a JSON array".to_string())?;
|
|
let skill = skill.trim();
|
|
if skill.is_empty() {
|
|
return Err("skill is empty".into());
|
|
}
|
|
let mut best: Option<&serde_json::Value> = None;
|
|
let mut best_load = i64::MAX;
|
|
for m in arr {
|
|
let sk = skills_text(m);
|
|
if sk.split(',').any(|p| p.trim() == skill) || sk.contains(skill) {
|
|
let load = map_get_i64(m, &["负载", "load"]);
|
|
if load < best_load {
|
|
best_load = load;
|
|
best = Some(m);
|
|
}
|
|
}
|
|
}
|
|
Ok(best.cloned().unwrap_or(serde_json::Value::Null))
|
|
}
|
|
|
|
fn bump_load(member: &serde_json::Value, delta: i64) -> Result<serde_json::Value, String> {
|
|
let mut obj = member
|
|
.as_object()
|
|
.cloned()
|
|
.ok_or_else(|| "member must be a JSON object".to_string())?;
|
|
let key = if obj.contains_key("负载") {
|
|
"负载"
|
|
} else if obj.contains_key("load") {
|
|
"load"
|
|
} else {
|
|
obj.insert("负载".into(), serde_json::Value::Number(0.into()));
|
|
"负载"
|
|
};
|
|
let cur = match obj.get(key) {
|
|
Some(serde_json::Value::Number(n)) => n.as_i64().unwrap_or(0),
|
|
Some(serde_json::Value::String(s)) => s.parse().unwrap_or(0),
|
|
_ => 0,
|
|
};
|
|
obj.insert(
|
|
key.into(),
|
|
serde_json::Value::Number((cur + delta).into()),
|
|
);
|
|
Ok(serde_json::Value::Object(obj))
|
|
}
|
|
|
|
unsafe extern "C" fn agent_find_root(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_find_root: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let start = match arg_str(&v, "start") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_find_root: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let markers = v
|
|
.get("markers")
|
|
.and_then(|x| x.as_str())
|
|
.filter(|s| !s.is_empty())
|
|
.unwrap_or(DEFAULT_MARKERS);
|
|
match find_root(start, markers) {
|
|
Ok(p) => {
|
|
let out = serde_json::Value::String(p.to_string_lossy().into_owned()).to_string();
|
|
set_out(out_json, &out);
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_find_root: {e}"));
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe extern "C" fn agent_ensure_layout(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_ensure_layout: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let root = match arg_str(&v, "root") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_ensure_layout: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
match ensure_layout(Path::new(root)) {
|
|
Ok(n) => {
|
|
set_out(out_json, &n.to_string());
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_ensure_layout: {e}"));
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe extern "C" fn agent_probe(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_probe: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let root = match arg_str(&v, "root") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_probe: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
match probe(Path::new(root)) {
|
|
Ok(j) => {
|
|
set_out(out_json, &j.to_string());
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_probe: {e}"));
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe extern "C" fn agent_scaffold(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_scaffold: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let root = match arg_str(&v, "root") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_scaffold: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let name = match arg_str(&v, "name") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_scaffold: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let template = match arg_str(&v, "template") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_scaffold: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let dest = match arg_str(&v, "dest") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_scaffold: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
match scaffold(Path::new(root), name, template, dest) {
|
|
Ok(p) => {
|
|
let out = serde_json::Value::String(p).to_string();
|
|
set_out(out_json, &out);
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_scaffold: {e}"));
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe extern "C" fn agent_match_skill(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_match_skill: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let skill = match arg_str(&v, "skill") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_match_skill: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let members = match v.get("members") {
|
|
Some(m) => m.clone(),
|
|
None => {
|
|
set_err(err_msg, "agent_match_skill: missing members");
|
|
return 1;
|
|
}
|
|
};
|
|
// members may be a JSON string (from Marqdo stringify) or already an array
|
|
let members = if let Some(s) = members.as_str() {
|
|
match serde_json::from_str::<serde_json::Value>(s) {
|
|
Ok(j) => j,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_match_skill: members JSON: {e}"));
|
|
return 1;
|
|
}
|
|
}
|
|
} else {
|
|
members
|
|
};
|
|
match match_skill(skill, &members) {
|
|
Ok(j) => {
|
|
set_out(out_json, &j.to_string());
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_match_skill: {e}"));
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe extern "C" fn agent_bump_load(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_bump_load: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let member = match v.get("member") {
|
|
Some(m) => m.clone(),
|
|
None => {
|
|
set_err(err_msg, "agent_bump_load: missing member");
|
|
return 1;
|
|
}
|
|
};
|
|
let member = if let Some(s) = member.as_str() {
|
|
match serde_json::from_str::<serde_json::Value>(s) {
|
|
Ok(j) => j,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_bump_load: member JSON: {e}"));
|
|
return 1;
|
|
}
|
|
}
|
|
} else {
|
|
member
|
|
};
|
|
let delta = v.get("delta").and_then(|x| x.as_i64()).unwrap_or(1);
|
|
match bump_load(&member, delta) {
|
|
Ok(j) => {
|
|
set_out(out_json, &j.to_string());
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_bump_load: {e}"));
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
fn register(host: &MarqdoHostApi, name: &str, params: &str, fn_ptr: PluginFn) -> c_int {
|
|
let register = match host.register_fn {
|
|
Some(f) => f,
|
|
None => return 1,
|
|
};
|
|
let n = CString::new(name).unwrap();
|
|
let p = CString::new(params).unwrap();
|
|
unsafe { register(host.userdata, n.as_ptr(), p.as_ptr(), fn_ptr) }
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn marqdo_plugin_abi_version() -> u32 {
|
|
ABI_VERSION
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn marqdo_plugin_init(host: *const MarqdoHostApi) -> c_int {
|
|
if host.is_null() {
|
|
return 1;
|
|
}
|
|
let host = &*host;
|
|
HOST_ALLOC = host.alloc;
|
|
HOST_FREE = host.free;
|
|
if register(host, "agent_find_root", "start,markers", agent_find_root) != 0 {
|
|
return 1;
|
|
}
|
|
if register(host, "agent_ensure_layout", "root", agent_ensure_layout) != 0 {
|
|
return 1;
|
|
}
|
|
if register(host, "agent_probe", "root", agent_probe) != 0 {
|
|
return 1;
|
|
}
|
|
if register(
|
|
host,
|
|
"agent_scaffold",
|
|
"root,name,template,dest",
|
|
agent_scaffold,
|
|
) != 0
|
|
{
|
|
return 1;
|
|
}
|
|
if register(host, "agent_match_skill", "skill,members", agent_match_skill) != 0 {
|
|
return 1;
|
|
}
|
|
if register(host, "agent_bump_load", "member,delta", agent_bump_load) != 0 {
|
|
return 1;
|
|
}
|
|
0
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn marqdo_plugin_shutdown() {
|
|
HOST_ALLOC = None;
|
|
HOST_FREE = None;
|
|
}
|