use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::{Mutex, OnceLock};
use crate::models::{EntityKind, ParsedEntity};
const PACKAGE_ID_MARKER: &str = "identity: package_id";
const UTF8_BOM: &[u8] = &[0xEF, 0xBB, 0xBF];
fn strip_utf8_bom(source: &str) -> &str {
source.strip_prefix('\u{FEFF}').unwrap_or(source)
}
fn child_text(parent: &roxmltree::Node, tag: &str) -> Option<String> {
for node in parent.descendants() {
if node.tag_name().name() == tag
&& let Some(text) = node.text()
{
return Some(text.trim().to_string());
}
}
None
}
fn attr(node: roxmltree::Node, attr: &str) -> Option<String> {
node.attributes()
.find(|a| a.name() == attr)
.map(|a| a.value().trim().to_string())
}
fn strip_bom_bytes(bytes: &[u8]) -> &[u8] {
bytes.strip_prefix(UTF8_BOM).unwrap_or(bytes)
}
type CpmMap = HashMap<String, String>;
static CPM_CACHE: OnceLock<Mutex<HashMap<PathBuf, CpmMap>>> = OnceLock::new();
fn cpm_cache() -> &'static Mutex<HashMap<PathBuf, CpmMap>> {
CPM_CACHE.get_or_init(|| Mutex::new(HashMap::new()))
}
fn find_nearest_props(start_dir: &Path, repo_root: &Path) -> Option<PathBuf> {
let mut current: Option<&Path> = Some(start_dir);
while let Some(dir) = current {
let candidate = dir.join("Directory.Packages.props");
if candidate.is_file() {
return Some(candidate);
}
if dir == repo_root {
return None;
}
current = dir.parent();
}
None
}
fn parse_props_file(path: &Path) -> CpmMap {
let Ok(bytes) = std::fs::read(path) else {
return HashMap::new();
};
let Ok(source) = std::str::from_utf8(strip_bom_bytes(&bytes)) else {
return HashMap::new();
};
let doc = match roxmltree::Document::parse(source) {
Ok(d) => d,
Err(_) => return HashMap::new(),
};
let mut map = HashMap::new();
for item in doc.descendants().filter(|n| {
n.tag_name().name() == "PackageVersion" || n.tag_name().name() == "PackageVersionOverride"
}) {
if let (Some(include), Some(version)) = (attr(item, "Include"), attr(item, "Version")) {
map.insert(include, version);
}
}
map
}
fn cpm_map_for(start_dir: &Path, repo_root: &Path) -> CpmMap {
let Some(props_path) = find_nearest_props(start_dir, repo_root) else {
return HashMap::new();
};
let cache = cpm_cache();
let mut guard = cache
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
if let Some(map) = guard.get(&props_path) {
return map.clone();
}
let map = parse_props_file(&props_path);
guard.insert(props_path, map.clone());
map
}
pub(crate) fn extract_entities_csproj(ctx: &MsbuildContext<'_>) -> Vec<ParsedEntity> {
let mut entities = Vec::new();
let doc = match roxmltree::Document::parse(strip_utf8_bom(ctx.source)) {
Ok(d) => d,
Err(_) => return entities,
};
let root = doc.root_element();
let cpm = cpm_map_for(ctx.csproj_abs_dir, ctx.repo_root);
let stem = Path::new(ctx.file_path)
.file_stem()
.and_then(|s| s.to_str())
.unwrap_or("unknown");
let (identity, identity_marker) = if let Some(pkg_id) = child_text(&root, "PackageId") {
(pkg_id, Some(PACKAGE_ID_MARKER))
} else if let Some(asm) = child_text(&root, "AssemblyName") {
(asm, None)
} else {
(stem.to_string(), None)
};
let version = child_text(&root, "Version").unwrap_or_else(|| "unknown".to_string());
let fqn = format!("nuget:{identity}");
let mut signature = format!("version: {}, build_system: nuget", version);
if let Some(marker) = identity_marker {
signature.push_str(", ");
signature.push_str(marker);
}
entities.push(ParsedEntity::new(
&identity,
EntityKind::ProjectIdentity,
&fqn,
Some(signature),
Some(format!("NuGet project identity: {identity}")),
"csproj",
ctx.file_path,
1,
1,
None,
ctx.repo_name,
));
for item in root
.descendants()
.filter(|n| n.tag_name().name() == "PackageReference")
{
let include = attr(item, "Include").or_else(|| attr(item, "Update"));
let Some(name) = include else { continue };
let version = if let Some(v) = attr(item, "Version") {
v
} else if let Some(v) = cpm.get(&name) {
v.clone()
} else {
"unknown".to_string()
};
let dep_name = format!("nuget:{name}:{version}");
let dep_fqn = dep_name.clone();
entities.push(ParsedEntity::new(
&dep_name,
EntityKind::BuildDependency,
&dep_fqn,
None,
Some(format!("NuGet dependency: {name}")),
"csproj",
ctx.file_path,
1,
1,
None,
ctx.repo_name,
));
}
entities
}
pub(crate) struct MsbuildContext<'a> {
pub source: &'a str,
pub file_path: &'a str,
pub repo_name: &'a str,
pub csproj_abs_dir: &'a Path,
pub repo_root: &'a Path,
}
pub(crate) fn extract_entities_props(
_source: &str,
_file_path: &str,
_repo_name: &str,
) -> Vec<ParsedEntity> {
Vec::new()
}
#[cfg(test)]
mod tests {
use super::*;
fn call_extract(
source: &str,
file_path: &str,
abs_dir: &str,
abs_root: &str,
) -> Vec<ParsedEntity> {
let ctx = MsbuildContext {
source,
file_path,
repo_name: "test-repo",
csproj_abs_dir: Path::new(abs_dir),
repo_root: Path::new(abs_root),
};
extract_entities_csproj(&ctx)
}
#[test]
fn test_extract_csproj_package_reference_attribute_version() {
let source = r#"<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Tomlyn" Version="0.17.0" />
</ItemGroup>
</Project>"#;
let entities = call_extract(source, "src/App/App.csproj", "/repo/src/App", "/repo");
let deps: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::BuildDependency)
.collect();
assert_eq!(deps.len(), 1, "expected one BuildDependency");
assert_eq!(deps[0].name, "nuget:Tomlyn:0.17.0");
assert_eq!(deps[0].fqn, "nuget:Tomlyn:0.17.0");
assert!(deps[0].docstring.as_ref().unwrap().contains("NuGet"));
}
#[test]
fn test_extract_csproj_identity_from_package_id() {
let source = r#"<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<PackageId>codemap-mcp</PackageId>
<Version>2.8.1</Version>
<TargetFramework>net8.0</TargetFramework>
</PropertyGroup>
</Project>"#;
let entities = call_extract(
source,
"src/CodeMap.Daemon/CodeMap.Daemon.csproj",
"/repo/src/CodeMap.Daemon",
"/repo",
);
let identities: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::ProjectIdentity)
.collect();
assert_eq!(identities.len(), 1);
assert_eq!(identities[0].name, "codemap-mcp");
assert_eq!(identities[0].fqn, "nuget:codemap-mcp");
let sig = identities[0].signature.as_ref().unwrap();
assert!(sig.contains("version: 2.8.1"));
assert!(sig.contains("build_system: nuget"));
assert!(
sig.contains("identity: package_id"),
"PackageId path must carry the marker, got {sig}"
);
}
#[test]
fn test_extract_csproj_identity_falls_back_to_assembly_name() {
let source = r#"<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<AssemblyName>OpenLogi.Agent</AssemblyName>
</PropertyGroup>
</Project>"#;
let entities = call_extract(
source,
"src/OpenLogi/OpenLogi.Agent.csproj",
"/repo/src/OpenLogi",
"/repo",
);
let identities: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::ProjectIdentity)
.collect();
assert_eq!(identities.len(), 1);
assert_eq!(identities[0].name, "OpenLogi.Agent");
assert_eq!(identities[0].fqn, "nuget:OpenLogi.Agent");
let sig = identities[0].signature.as_ref().unwrap();
assert!(
!sig.contains("identity: package_id"),
"AssemblyName path must NOT carry the marker, got {sig}"
);
}
#[test]
fn test_extract_csproj_identity_falls_back_to_file_stem() {
let source = r#"<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
</PropertyGroup>
</Project>"#;
let entities = call_extract(source, "src/MyApp/MyApp.csproj", "/repo/src/MyApp", "/repo");
let identities: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::ProjectIdentity)
.collect();
assert_eq!(identities.len(), 1);
assert_eq!(identities[0].name, "MyApp");
assert_eq!(identities[0].fqn, "nuget:MyApp");
}
#[test]
fn test_extract_csproj_version_property() {
let source = r#"<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<Version>1.4.0</Version>
</PropertyGroup>
</Project>"#;
let entities = call_extract(source, "src/MyApp/MyApp.csproj", "/repo/src/MyApp", "/repo");
let identities: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::ProjectIdentity)
.collect();
let sig = identities[0].signature.as_ref().unwrap();
assert!(sig.contains("version: 1.4.0"), "got {sig}");
}
#[test]
fn test_extract_csproj_project_reference_skipped() {
let source = r#"<Project Sdk="Microsoft.NET.Sdk">
<ItemGroup>
<ProjectReference Include="..\Other\Other.csproj" />
</ItemGroup>
</Project>"#;
let entities = call_extract(source, "src/App/App.csproj", "/repo/src/App", "/repo");
let deps: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::BuildDependency)
.collect();
assert!(deps.is_empty(), "ProjectReference must be skipped");
}
#[test]
fn test_extract_csproj_tolerates_utf8_bom() {
let source = "\u{FEFF}<Project Sdk=\"Microsoft.NET.Sdk\">
<PropertyGroup>
<PackageId>codemap-mcp</PackageId>
<Version>2.8.1</Version>
</PropertyGroup>
<ItemGroup>
<PackageReference Include=\"Tomlyn\" Version=\"0.17.0\" />
</ItemGroup>
</Project>";
let entities = call_extract(
source,
"src/CodeMap.Daemon/CodeMap.Daemon.csproj",
"/repo/src/CodeMap.Daemon",
"/repo",
);
assert!(
!entities.is_empty(),
"BOM-stripped parse must yield entities"
);
let identities: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::ProjectIdentity)
.collect();
assert_eq!(
identities.len(),
1,
"ProjectIdentity must survive BOM strip"
);
assert_eq!(identities[0].name, "codemap-mcp");
let deps: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::BuildDependency)
.collect();
assert_eq!(deps.len(), 1);
assert_eq!(deps[0].name, "nuget:Tomlyn:0.17.0");
}
#[test]
fn test_extract_csproj_empty_project_yields_identity_only() {
let source = r#"<Project />"#;
let entities = call_extract(source, "src/Empty/Empty.csproj", "/repo/src/Empty", "/repo");
let deps: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::BuildDependency)
.collect();
assert!(deps.is_empty(), "no dependencies from an empty project");
let identities: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::ProjectIdentity)
.collect();
assert_eq!(identities.len(), 1);
assert_eq!(identities[0].name, "Empty");
assert_eq!(identities[0].fqn, "nuget:Empty");
}
#[test]
fn test_extract_csproj_xmlns_and_conditions_ignored() {
let source = r#"<?xml version="1.0" encoding="utf-8"?>
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<PackageReference Include="Tomlyn" Version="0.17.0" Condition="'$(Configuration)' == 'Release'" />
</ItemGroup>
</Project>"#;
let entities = call_extract(
source,
"src/Legacy/Legacy.csproj",
"/repo/src/Legacy",
"/repo",
);
let deps: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::BuildDependency)
.collect();
assert_eq!(deps.len(), 1, "xmlns + Condition must not block extraction");
assert_eq!(deps[0].name, "nuget:Tomlyn:0.17.0");
}
#[test]
fn test_extract_csproj_versionless_without_props_is_unknown() {
let source = r#"<Project Sdk="Microsoft.NET.Sdk">
<ItemGroup>
<PackageReference Include="LibGit2Sharp" />
</ItemGroup>
</Project>"#;
let entities = call_extract(
source,
"src/App/App.csproj",
"/__nonexistent_repo__/src/App",
"/__nonexistent_repo__",
);
let deps: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::BuildDependency)
.collect();
assert_eq!(deps.len(), 1);
assert_eq!(deps[0].name, "nuget:LibGit2Sharp:unknown");
}
#[test]
fn test_extract_csproj_package_reference_update_attribute() {
let source = r#"<Project Sdk="Microsoft.NET.Sdk">
<ItemGroup>
<PackageReference Update="Serilog" Version="3.1.0" />
</ItemGroup>
</Project>"#;
let entities = call_extract(source, "src/App/App.csproj", "/repo/src/App", "/repo");
let deps: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::BuildDependency)
.collect();
assert_eq!(deps.len(), 1);
assert_eq!(deps[0].name, "nuget:Serilog:3.1.0");
}
#[test]
fn test_extract_csproj_cpm_resolves_version_from_props() {
let csproj = r#"<Project Sdk="Microsoft.NET.Sdk">
<ItemGroup>
<PackageReference Include="LibGit2Sharp" />
<PackageReference Include="Tomlyn" Version="0.17.0" />
</ItemGroup>
</Project>"#;
let dir = tempfile::tempdir().unwrap();
let repo_root = dir.path();
let app_dir = repo_root.join("src").join("App");
std::fs::create_dir_all(&app_dir).unwrap();
std::fs::write(app_dir.join("App.csproj"), csproj).unwrap();
let props_source = r#"<Project>
<ItemGroup>
<PackageVersion Include="LibGit2Sharp" Version="0.30.0" />
<PackageVersion Include="Tomlyn" Version="0.17.0" />
</ItemGroup>
</Project>"#;
std::fs::write(repo_root.join("Directory.Packages.props"), props_source).unwrap();
let entities = call_extract(
csproj,
"src/App/App.csproj",
app_dir.to_str().unwrap(),
repo_root.to_str().unwrap(),
);
let deps: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::BuildDependency)
.collect();
assert_eq!(deps.len(), 2);
let lib = deps
.iter()
.find(|d| d.name.starts_with("nuget:LibGit2Sharp"))
.unwrap();
assert_eq!(
lib.name, "nuget:LibGit2Sharp:0.30.0",
"CPM must resolve the version"
);
let tomlyn = deps
.iter()
.find(|d| d.name.starts_with("nuget:Tomlyn"))
.unwrap();
assert_eq!(tomlyn.name, "nuget:Tomlyn:0.17.0");
}
#[test]
fn test_extract_csproj_cpm_nearest_ancestor_wins() {
let csproj = r#"<Project Sdk="Microsoft.NET.Sdk">
<ItemGroup>
<PackageReference Include="Foo" />
</ItemGroup>
</Project>"#;
let dir = tempfile::tempdir().unwrap();
let repo_root = dir.path();
let app_dir = repo_root.join("src").join("App");
std::fs::create_dir_all(&app_dir).unwrap();
std::fs::write(app_dir.join("App.csproj"), csproj).unwrap();
let root_props = r#"<Project>
<ItemGroup>
<PackageVersion Include="Foo" Version="1.0.0" />
</ItemGroup>
</Project>"#;
std::fs::write(repo_root.join("Directory.Packages.props"), root_props).unwrap();
let local_props = r#"<Project>
<ItemGroup>
<PackageVersion Include="Foo" Version="2.0.0" />
</ItemGroup>
</Project>"#;
std::fs::write(app_dir.join("Directory.Packages.props"), local_props).unwrap();
let entities = call_extract(
csproj,
"src/App/App.csproj",
app_dir.to_str().unwrap(),
repo_root.to_str().unwrap(),
);
let deps: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::BuildDependency)
.collect();
assert_eq!(deps.len(), 1);
assert_eq!(
deps[0].name, "nuget:Foo:2.0.0",
"nearest ancestor must win (2.0.0 from the project dir)"
);
}
#[test]
fn test_cpm_cache_parses_props_once() {
let csproj = r#"<Project Sdk="Microsoft.NET.Sdk">
<ItemGroup>
<PackageReference Include="Shared" />
</ItemGroup>
</Project>"#;
let dir = tempfile::tempdir().unwrap();
let repo_root = dir.path();
let a_dir = repo_root.join("src").join("A");
let b_dir = repo_root.join("src").join("B");
std::fs::create_dir_all(&a_dir).unwrap();
std::fs::create_dir_all(&b_dir).unwrap();
std::fs::write(a_dir.join("A.csproj"), csproj).unwrap();
std::fs::write(b_dir.join("B.csproj"), csproj).unwrap();
let props_source = r#"<Project>
<ItemGroup>
<PackageVersion Include="Shared" Version="9.9.9" />
</ItemGroup>
</Project>"#;
let props_path = repo_root.join("Directory.Packages.props");
std::fs::write(&props_path, props_source).unwrap();
let entities_a = call_extract(
csproj,
"src/A/A.csproj",
a_dir.to_str().unwrap(),
repo_root.to_str().unwrap(),
);
let entities_b = call_extract(
csproj,
"src/B/B.csproj",
b_dir.to_str().unwrap(),
repo_root.to_str().unwrap(),
);
for entities in [&entities_a, &entities_b] {
let dep = entities
.iter()
.find(|e| e.kind == EntityKind::BuildDependency)
.unwrap();
assert_eq!(dep.name, "nuget:Shared:9.9.9");
}
let cache = cpm_cache().lock().unwrap();
let entry = cache
.get(&props_path)
.expect("props path must be cached after at least one csproj lookup");
assert_eq!(entry.get("Shared").map(String::as_str), Some("9.9.9"));
}
#[test]
fn test_extract_csproj_under_root_dir_with_no_props() {
let csproj = r#"<Project Sdk="Microsoft.NET.Sdk">
<ItemGroup>
<PackageReference Include="Foo" />
</ItemGroup>
</Project>"#;
let dir = tempfile::tempdir().unwrap();
let repo_root = dir.path();
let app_dir = repo_root.join("src").join("App");
std::fs::create_dir_all(&app_dir).unwrap();
std::fs::write(app_dir.join("App.csproj"), csproj).unwrap();
let entities = call_extract(
csproj,
"src/App/App.csproj",
app_dir.to_str().unwrap(),
repo_root.to_str().unwrap(),
);
let deps: Vec<_> = entities
.iter()
.filter(|e| e.kind == EntityKind::BuildDependency)
.collect();
assert_eq!(deps.len(), 1);
assert_eq!(deps[0].name, "nuget:Foo:unknown");
}
#[test]
fn test_strip_bom_bytes_handles_no_bom() {
let no_bom = b"<Project />";
assert_eq!(strip_bom_bytes(no_bom), no_bom);
}
#[test]
fn test_strip_bom_bytes_strips_leading_bom() {
let bom = [0xEF, 0xBB, 0xBF];
let mut with_bom = Vec::from(bom);
with_bom.extend_from_slice(b"<Project />");
let stripped = strip_bom_bytes(&with_bom);
assert_eq!(stripped, b"<Project />");
}
#[test]
fn test_extract_entities_props_is_empty() {
let entities = extract_entities_props("<Project />", "Directory.Packages.props", "x");
assert!(entities.is_empty());
}
}