use std::path::{Path, PathBuf};
pub const CONVENTIONAL_SIBLING_DIR: &str = "Agent_Army_Professionals";
pub const AAP_ROOT_ENV: &str = "AAP_ROOT";
pub fn running_version() -> &'static str {
env!("CARGO_PKG_VERSION")
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "snake_case")]
pub enum DetectionSource {
EnvVar,
ConventionalSibling,
}
impl DetectionSource {
pub fn label(self) -> &'static str {
match self {
DetectionSource::EnvVar => "env",
DetectionSource::ConventionalSibling => "sibling",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AapDetection {
pub detected: bool,
pub root: Option<PathBuf>,
pub source: Option<DetectionSource>,
}
impl AapDetection {
fn not_detected() -> Self {
Self {
detected: false,
root: None,
source: None,
}
}
pub fn resolve() -> Self {
let cwd = std::env::current_dir().ok();
Self::resolve_with(std::env::var_os(AAP_ROOT_ENV), cwd.as_deref())
}
pub fn resolve_with(
aap_root_env: Option<std::ffi::OsString>,
symforge_root: Option<&Path>,
) -> Self {
if let Some(raw) = aap_root_env {
let candidate = PathBuf::from(&raw);
if !candidate.as_os_str().is_empty() && candidate.is_dir() {
return Self {
detected: true,
root: Some(candidate),
source: Some(DetectionSource::EnvVar),
};
}
}
if let Some(root) = symforge_root
&& let Some(parent) = root.parent()
{
let candidate = parent.join(CONVENTIONAL_SIBLING_DIR);
if candidate.is_dir() {
return Self {
detected: true,
root: Some(candidate),
source: Some(DetectionSource::ConventionalSibling),
};
}
}
Self::not_detected()
}
}
pub fn read_symforge_pin(root: &Path) -> Option<String> {
let lock_path = root.join("Cargo.lock");
let text = std::fs::read_to_string(&lock_path).ok()?;
parse_symforge_pin(&text)
}
pub fn parse_symforge_pin(lock_text: &str) -> Option<String> {
let doc = lock_text.parse::<toml_edit::DocumentMut>().ok()?;
let packages = doc.get("package")?.as_array_of_tables()?;
for pkg in packages.iter() {
let name = pkg.get("name").and_then(|v| v.as_str());
if name == Some(SYMFORGE_PACKAGE_NAME) {
return pkg
.get("version")
.and_then(|v| v.as_str())
.map(str::to_string);
}
}
None
}
const SYMFORGE_PACKAGE_NAME: &str = "symforge";
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum EmbedPinComparison {
Drift {
pinned: String,
running: String,
},
Match {
version: String,
},
PinUnknown {
running: String,
},
}
impl EmbedPinComparison {
pub fn evaluate(pinned: Option<String>, running: &str) -> Self {
match pinned {
Some(pinned) if pinned == running => Self::Match { version: pinned },
Some(pinned) => Self::Drift {
pinned,
running: running.to_string(),
},
None => Self::PinUnknown {
running: running.to_string(),
},
}
}
pub fn for_root(root: &Path) -> Self {
Self::evaluate(read_symforge_pin(root), running_version())
}
pub fn is_drift(&self) -> bool {
matches!(self, Self::Drift { .. })
}
pub fn label(&self) -> &'static str {
match self {
Self::Drift { .. } => "drift",
Self::Match { .. } => "match",
Self::PinUnknown { .. } => "pin_unknown",
}
}
pub fn pinned_version(&self) -> Option<&str> {
match self {
Self::Drift { pinned, .. } => Some(pinned),
Self::Match { version } => Some(version),
Self::PinUnknown { .. } => None,
}
}
pub fn running_version(&self) -> &str {
match self {
Self::Drift { running, .. } => running,
Self::Match { version } => version,
Self::PinUnknown { running } => running,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "snake_case")]
pub enum IntegrationMode {
Embed,
McpUrl,
Both,
None,
}
impl IntegrationMode {
pub fn classify(detected: bool, serve_url_configured: bool) -> Self {
match (detected, serve_url_configured) {
(false, _) => Self::None,
(true, false) => Self::Embed,
(true, true) => Self::Both,
}
}
pub fn label(self) -> &'static str {
match self {
IntegrationMode::Embed => "embed",
IntegrationMode::McpUrl => "mcp_url",
IntegrationMode::Both => "both",
IntegrationMode::None => "none",
}
}
}
pub const EMBED_PATH_DEP_REL: &str = "../symforge";
pub fn embed_cargo_snippet() -> String {
format!("symforge = {{ path = \"{EMBED_PATH_DEP_REL}\", features = [\"embed\"] }}")
}
pub const ADMIN_SERVE_KEY_PLACEHOLDER: &str = "<API_KEY>";
pub fn serve_url_preset(attach_url: &str, key: Option<&str>) -> String {
let mut server = serde_json::json!({
"type": "http",
"url": attach_url,
});
if let Some(key) = key.filter(|k| !k.is_empty()) {
server["headers"] = serde_json::json!({ "Authorization": format!("Bearer {key}") });
}
let doc = serde_json::json!({ "mcpServers": { "symforge": server } });
serde_json::to_string_pretty(&doc).unwrap_or_else(|_| "{}".to_string())
}
pub fn serve_url_preset_for_admin(attach_url: &str, bootstrap_key_configured: bool) -> String {
if bootstrap_key_configured {
serve_url_preset(attach_url, Some(ADMIN_SERVE_KEY_PLACEHOLDER))
} else {
serve_url_preset(attach_url, None)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AapPresets {
pub embed_snippet: String,
pub serve_url_snippet: Option<String>,
}
impl AapPresets {
pub fn build(serve: Option<(&str, Option<&str>)>) -> Self {
Self {
embed_snippet: embed_cargo_snippet(),
serve_url_snippet: serve.map(|(url, key)| serve_url_preset(url, key)),
}
}
pub fn build_for_admin_panel(
serve_active: bool,
attach_url: &str,
bootstrap_key_configured: bool,
) -> Self {
Self {
embed_snippet: embed_cargo_snippet(),
serve_url_snippet: serve_active
.then(|| serve_url_preset_for_admin(attach_url, bootstrap_key_configured)),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn resolve_env_var_wins_when_dir_exists() {
let dir = tempfile::tempdir().unwrap();
let det = AapDetection::resolve_with(Some(dir.path().as_os_str().to_owned()), None);
assert!(det.detected);
assert_eq!(det.source, Some(DetectionSource::EnvVar));
assert_eq!(det.root.as_deref(), Some(dir.path()));
}
#[test]
fn resolve_env_var_missing_path_is_not_detected_without_sibling() {
let det = AapDetection::resolve_with(
Some(std::ffi::OsString::from("/no/such/aap/root/xyz")),
None,
);
assert!(!det.detected);
assert!(det.root.is_none());
assert!(det.source.is_none());
}
#[test]
fn resolve_conventional_sibling_when_present() {
let tmp = tempfile::tempdir().unwrap();
let symforge_root = tmp.path().join("symforge");
let sibling = tmp.path().join(CONVENTIONAL_SIBLING_DIR);
std::fs::create_dir_all(&symforge_root).unwrap();
std::fs::create_dir_all(&sibling).unwrap();
let det = AapDetection::resolve_with(None, Some(&symforge_root));
assert!(det.detected);
assert_eq!(det.source, Some(DetectionSource::ConventionalSibling));
assert_eq!(det.root.as_deref(), Some(sibling.as_path()));
}
#[test]
fn resolve_env_takes_precedence_over_sibling() {
let tmp = tempfile::tempdir().unwrap();
let symforge_root = tmp.path().join("symforge");
let sibling = tmp.path().join(CONVENTIONAL_SIBLING_DIR);
let env_root = tmp.path().join("explicit-aap");
std::fs::create_dir_all(&symforge_root).unwrap();
std::fs::create_dir_all(&sibling).unwrap();
std::fs::create_dir_all(&env_root).unwrap();
let det =
AapDetection::resolve_with(Some(env_root.as_os_str().to_owned()), Some(&symforge_root));
assert!(det.detected);
assert_eq!(det.source, Some(DetectionSource::EnvVar));
assert_eq!(det.root.as_deref(), Some(env_root.as_path()));
}
#[test]
fn resolve_no_env_no_sibling_is_not_detected() {
let tmp = tempfile::tempdir().unwrap();
let symforge_root = tmp.path().join("symforge");
std::fs::create_dir_all(&symforge_root).unwrap();
let det = AapDetection::resolve_with(None, Some(&symforge_root));
assert!(!det.detected);
}
#[test]
fn parse_pin_extracts_symforge_version() {
let lock = r#"
version = 4
[[package]]
name = "aap-code-intel"
version = "0.1.0"
[[package]]
name = "symforge"
version = "7.0.0"
"#;
assert_eq!(parse_symforge_pin(lock).as_deref(), Some("7.0.0"));
}
#[test]
fn parse_pin_none_when_no_symforge_package() {
let lock = r#"
version = 4
[[package]]
name = "serde"
version = "1.0.0"
"#;
assert!(parse_symforge_pin(lock).is_none());
}
#[test]
fn parse_pin_none_when_unparseable() {
assert!(parse_symforge_pin("{ this is not toml").is_none());
}
#[test]
fn read_pin_none_when_lock_missing() {
let dir = tempfile::tempdir().unwrap();
assert!(read_symforge_pin(dir.path()).is_none());
}
#[test]
fn evaluate_drift_when_versions_differ() {
let cmp = EmbedPinComparison::evaluate(Some("7.0.0".to_string()), "7.29.0");
assert!(cmp.is_drift());
assert_eq!(cmp.label(), "drift");
assert_eq!(cmp.pinned_version(), Some("7.0.0"));
assert_eq!(cmp.running_version(), "7.29.0");
}
#[test]
fn evaluate_match_when_versions_equal() {
let cmp = EmbedPinComparison::evaluate(Some("7.29.0".to_string()), "7.29.0");
assert!(!cmp.is_drift());
assert_eq!(cmp.label(), "match");
assert_eq!(cmp.pinned_version(), Some("7.29.0"));
}
#[test]
fn evaluate_pin_unknown_when_no_pin() {
let cmp = EmbedPinComparison::evaluate(None, "7.29.0");
assert!(
!cmp.is_drift(),
"no pin must NOT raise a false drift warning"
);
assert_eq!(cmp.label(), "pin_unknown");
assert!(cmp.pinned_version().is_none());
assert_eq!(cmp.running_version(), "7.29.0");
}
#[test]
fn classify_integration_mode() {
assert_eq!(
IntegrationMode::classify(false, false),
IntegrationMode::None
);
assert_eq!(
IntegrationMode::classify(false, true),
IntegrationMode::None
);
assert_eq!(
IntegrationMode::classify(true, false),
IntegrationMode::Embed
);
assert_eq!(IntegrationMode::classify(true, true), IntegrationMode::Both);
}
#[test]
fn embed_snippet_is_path_dep_with_embed_feature_never_stdio() {
let snippet = embed_cargo_snippet();
assert!(snippet.contains("path = \"../symforge\""));
assert!(snippet.contains("features = [\"embed\"]"));
assert!(!snippet.contains("command"));
assert!(!snippet.contains("stdio"));
assert!(!snippet.contains("args"));
}
#[test]
fn serve_url_preset_is_http_with_key_never_stdio() {
let preset = serve_url_preset("http://127.0.0.1:8787/mcp", Some("sf_key"));
let v: serde_json::Value = serde_json::from_str(&preset).unwrap();
assert_eq!(v["mcpServers"]["symforge"]["type"], "http");
assert_eq!(
v["mcpServers"]["symforge"]["url"],
"http://127.0.0.1:8787/mcp"
);
assert_eq!(
v["mcpServers"]["symforge"]["headers"]["Authorization"],
"Bearer sf_key"
);
assert!(v["mcpServers"]["symforge"]["command"].is_null());
}
#[test]
fn serve_url_preset_omits_headers_without_key() {
let preset = serve_url_preset("http://127.0.0.1:8787/mcp", None);
let v: serde_json::Value = serde_json::from_str(&preset).unwrap();
assert!(v["mcpServers"]["symforge"]["headers"].is_null());
let preset2 = serve_url_preset("http://127.0.0.1:8787/mcp", Some(""));
let v2: serde_json::Value = serde_json::from_str(&preset2).unwrap();
assert!(v2["mcpServers"]["symforge"]["headers"].is_null());
}
#[test]
fn serve_url_preset_for_admin_redacts_bootstrap_key() {
let preset = serve_url_preset_for_admin("http://127.0.0.1:8787/mcp", true);
let v: serde_json::Value = serde_json::from_str(&preset).unwrap();
assert_eq!(
v["mcpServers"]["symforge"]["headers"]["Authorization"],
"Bearer <API_KEY>"
);
assert!(!preset.contains("sf_real_secret"));
}
#[test]
fn presets_embed_always_serve_only_when_active() {
let embed_only = AapPresets::build(None);
assert!(embed_only.embed_snippet.contains("embed"));
assert!(embed_only.serve_url_snippet.is_none());
let with_serve = AapPresets::build(Some(("http://127.0.0.1:8787/mcp", Some("k"))));
assert!(with_serve.embed_snippet.contains("embed"));
assert!(with_serve.serve_url_snippet.is_some());
}
}