use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs;
use std::path::{Path, PathBuf};
use crate::utils::fs::atomic_write;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StalenessReason {
MissingDependency {
name: String,
resource_type: crate::core::ResourceType,
},
VersionChanged {
name: String,
resource_type: crate::core::ResourceType,
old_version: String,
new_version: String,
},
PathChanged {
name: String,
resource_type: crate::core::ResourceType,
old_path: String,
new_path: String,
},
SourceUrlChanged {
name: String,
old_url: String,
new_url: String,
},
DuplicateEntries {
name: String,
resource_type: crate::core::ResourceType,
count: usize,
},
ToolChanged {
name: String,
resource_type: crate::core::ResourceType,
old_tool: String,
new_tool: String,
},
}
impl std::fmt::Display for StalenessReason {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::MissingDependency {
name,
resource_type,
} => {
write!(
f,
"Dependency '{name}' ({resource_type}) is in manifest but missing from lockfile"
)
}
Self::VersionChanged {
name,
resource_type,
old_version,
new_version,
} => {
write!(
f,
"Dependency '{name}' ({resource_type}) version changed from '{old_version}' to '{new_version}'"
)
}
Self::PathChanged {
name,
resource_type,
old_path,
new_path,
} => {
write!(
f,
"Dependency '{name}' ({resource_type}) path changed from '{old_path}' to '{new_path}'"
)
}
Self::SourceUrlChanged {
name,
old_url,
new_url,
} => {
write!(f, "Source repository '{name}' URL changed from '{old_url}' to '{new_url}'")
}
Self::DuplicateEntries {
name,
resource_type,
count,
} => {
write!(
f,
"Found {count} duplicate entries for dependency '{name}' ({resource_type})"
)
}
Self::ToolChanged {
name,
resource_type,
old_tool,
new_tool,
} => {
write!(
f,
"Dependency '{name}' ({resource_type}) tool changed from '{old_tool}' to '{new_tool}'"
)
}
}
}
}
impl std::error::Error for StalenessReason {}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LockFile {
pub version: u32,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub sources: Vec<LockedSource>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub agents: Vec<LockedResource>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub snippets: Vec<LockedResource>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub commands: Vec<LockedResource>,
#[serde(default, skip_serializing_if = "Vec::is_empty", rename = "mcp-servers")]
pub mcp_servers: Vec<LockedResource>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub scripts: Vec<LockedResource>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub hooks: Vec<LockedResource>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LockedSource {
pub name: String,
pub url: String,
pub fetched_at: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LockedResource {
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
pub path: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub resolved_commit: Option<String>,
pub checksum: String,
pub installed_at: String,
#[serde(default)]
pub dependencies: Vec<String>,
#[serde(skip)]
pub resource_type: crate::core::ResourceType,
#[serde(skip_serializing_if = "is_default_tool")]
pub tool: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_alias: Option<String>,
#[serde(default, skip_serializing_if = "HashMap::is_empty")]
pub applied_patches: HashMap<String, toml::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub install: Option<bool>,
}
fn is_default_tool(tool: &Option<String>) -> bool {
matches!(tool, Some(t) if t == "claude-code")
}
fn serialize_lockfile_with_inline_patches<T: serde::Serialize>(lockfile: &T) -> Result<String> {
use toml_edit::{DocumentMut, Item};
let toml_str = toml::to_string_pretty(lockfile).context("Failed to serialize to TOML")?;
let mut doc: DocumentMut = toml_str.parse().context("Failed to parse TOML document")?;
let resource_types = ["agents", "snippets", "commands", "scripts", "hooks", "mcp-servers"];
for resource_type in &resource_types {
if let Some(Item::ArrayOfTables(array)) = doc.get_mut(resource_type) {
for table in array.iter_mut() {
if let Some(Item::Table(patches_table)) = table.get_mut("applied_patches") {
let mut inline = toml_edit::InlineTable::new();
for (key, val) in patches_table.iter() {
if let Some(v) = val.as_value() {
inline.insert(key, v.clone());
}
}
table.insert("applied_patches", toml_edit::value(inline));
}
}
}
}
Ok(doc.to_string())
}
impl LockFile {
const CURRENT_VERSION: u32 = 1;
#[must_use]
pub const fn new() -> Self {
Self {
version: Self::CURRENT_VERSION,
sources: Vec::new(),
agents: Vec::new(),
snippets: Vec::new(),
commands: Vec::new(),
mcp_servers: Vec::new(),
scripts: Vec::new(),
hooks: Vec::new(),
}
}
pub fn load(path: &Path) -> Result<Self> {
if !path.exists() {
return Ok(Self::new());
}
let content = fs::read_to_string(path).with_context(|| {
format!(
"Cannot read lockfile: {}\n\n\
Possible causes:\n\
- File doesn't exist (run 'agpm install' to create it)\n\
- Permission denied (check file ownership)\n\
- File is corrupted or locked by another process",
path.display()
)
})?;
if content.trim().is_empty() {
return Ok(Self::new());
}
let mut lockfile: Self = toml::from_str(&content)
.map_err(|e| crate::core::AgpmError::LockfileParseError {
file: path.display().to_string(),
reason: e.to_string(),
})
.with_context(|| {
format!(
"Invalid TOML syntax in lockfile: {}\n\n\
The lockfile may be corrupted. You can:\n\
- Delete agpm.lock and run 'agpm install' to regenerate it\n\
- Check for syntax errors if you manually edited the file\n\
- Restore from backup if available",
path.display()
)
})?;
for resource in &mut lockfile.agents {
resource.resource_type = crate::core::ResourceType::Agent;
if resource.tool.is_none() {
resource.tool = Some(crate::core::ResourceType::Agent.default_tool().to_string());
}
}
for resource in &mut lockfile.snippets {
resource.resource_type = crate::core::ResourceType::Snippet;
if resource.tool.is_none() {
resource.tool = Some(crate::core::ResourceType::Snippet.default_tool().to_string());
}
}
for resource in &mut lockfile.commands {
resource.resource_type = crate::core::ResourceType::Command;
if resource.tool.is_none() {
resource.tool = Some(crate::core::ResourceType::Command.default_tool().to_string());
}
}
for resource in &mut lockfile.scripts {
resource.resource_type = crate::core::ResourceType::Script;
if resource.tool.is_none() {
resource.tool = Some(crate::core::ResourceType::Script.default_tool().to_string());
}
}
for resource in &mut lockfile.hooks {
resource.resource_type = crate::core::ResourceType::Hook;
if resource.tool.is_none() {
resource.tool = Some(crate::core::ResourceType::Hook.default_tool().to_string());
}
}
for resource in &mut lockfile.mcp_servers {
resource.resource_type = crate::core::ResourceType::McpServer;
if resource.tool.is_none() {
resource.tool =
Some(crate::core::ResourceType::McpServer.default_tool().to_string());
}
}
if lockfile.version > Self::CURRENT_VERSION {
return Err(crate::core::AgpmError::Other {
message: format!(
"Lockfile version {} is newer than supported version {}.\n\n\
This lockfile was created by a newer version of agpm.\n\
Please update agpm to the latest version to use this lockfile.",
lockfile.version,
Self::CURRENT_VERSION
),
}
.into());
}
Ok(lockfile)
}
pub fn save(&self, path: &Path) -> Result<()> {
let mut content = String::from("# Auto-generated lockfile - DO NOT EDIT\n");
let toml_content = serialize_lockfile_with_inline_patches(self)?;
content.push_str(&toml_content);
atomic_write(path, content.as_bytes()).with_context(|| {
format!(
"Cannot write lockfile: {}\n\n\
Possible causes:\n\
- Permission denied (try running with elevated permissions)\n\
- Directory doesn't exist\n\
- Disk is full or read-only\n\
- File is locked by another process",
path.display()
)
})?;
Ok(())
}
pub fn add_source(&mut self, name: String, url: String, _commit: String) {
self.sources.retain(|s| s.name != name);
self.sources.push(LockedSource {
name,
url,
fetched_at: chrono::Utc::now().to_rfc3339(),
});
}
pub fn add_resource(&mut self, name: String, resource: LockedResource, is_agent: bool) {
let resources = if is_agent {
&mut self.agents
} else {
&mut self.snippets
};
resources.retain(|r| r.name != name);
resources.push(resource);
}
pub fn add_typed_resource(
&mut self,
name: String,
resource: LockedResource,
resource_type: crate::core::ResourceType,
) {
let resources = match resource_type {
crate::core::ResourceType::Agent => &mut self.agents,
crate::core::ResourceType::Snippet => &mut self.snippets,
crate::core::ResourceType::Command => &mut self.commands,
crate::core::ResourceType::McpServer => {
return;
}
crate::core::ResourceType::Script => &mut self.scripts,
crate::core::ResourceType::Hook => &mut self.hooks,
};
resources.retain(|r| r.name != name);
resources.push(resource);
}
#[must_use]
pub fn get_resource(&self, name: &str) -> Option<&LockedResource> {
self.agents
.iter()
.find(|r| r.name == name)
.or_else(|| self.snippets.iter().find(|r| r.name == name))
.or_else(|| self.commands.iter().find(|r| r.name == name))
.or_else(|| self.scripts.iter().find(|r| r.name == name))
.or_else(|| self.hooks.iter().find(|r| r.name == name))
.or_else(|| self.mcp_servers.iter().find(|r| r.name == name))
}
#[must_use]
pub fn get_resource_by_source(
&self,
name: &str,
source: Option<&str>,
) -> Option<&LockedResource> {
let matches = |r: &&LockedResource| r.name == name && r.source.as_deref() == source;
self.agents
.iter()
.find(matches)
.or_else(|| self.snippets.iter().find(matches))
.or_else(|| self.commands.iter().find(matches))
.or_else(|| self.scripts.iter().find(matches))
.or_else(|| self.hooks.iter().find(matches))
.or_else(|| self.mcp_servers.iter().find(matches))
}
#[must_use]
pub fn get_source(&self, name: &str) -> Option<&LockedSource> {
self.sources.iter().find(|s| s.name == name)
}
#[must_use]
pub fn has_resource(&self, name: &str) -> bool {
self.get_resource(name).is_some()
}
pub fn get_resources(&self, resource_type: crate::core::ResourceType) -> &[LockedResource] {
use crate::core::ResourceType;
match resource_type {
ResourceType::Agent => &self.agents,
ResourceType::Snippet => &self.snippets,
ResourceType::Command => &self.commands,
ResourceType::Script => &self.scripts,
ResourceType::Hook => &self.hooks,
ResourceType::McpServer => &self.mcp_servers,
}
}
pub const fn get_resources_mut(
&mut self,
resource_type: crate::core::ResourceType,
) -> &mut Vec<LockedResource> {
use crate::core::ResourceType;
match resource_type {
ResourceType::Agent => &mut self.agents,
ResourceType::Snippet => &mut self.snippets,
ResourceType::Command => &mut self.commands,
ResourceType::Script => &mut self.scripts,
ResourceType::Hook => &mut self.hooks,
ResourceType::McpServer => &mut self.mcp_servers,
}
}
#[must_use]
pub fn all_resources(&self) -> Vec<&LockedResource> {
let mut resources = Vec::new();
for resource_type in crate::core::ResourceType::all() {
resources.extend(self.get_resources(*resource_type));
}
resources
}
pub fn clear(&mut self) {
self.sources.clear();
for resource_type in crate::core::ResourceType::all() {
self.get_resources_mut(*resource_type).clear();
}
}
pub fn compute_checksum(path: &Path) -> Result<String> {
use sha2::{Digest, Sha256};
let content = fs::read(path).with_context(|| {
format!(
"Cannot read file for checksum calculation: {}\n\n\
This error occurs when verifying file integrity.\n\
Check that the file exists and is readable.",
path.display()
)
})?;
let mut hasher = Sha256::new();
hasher.update(&content);
let result = hasher.finalize();
Ok(format!("sha256:{}", hex::encode(result)))
}
pub fn verify_checksum(path: &Path, expected: &str) -> Result<bool> {
let actual = Self::compute_checksum(path)?;
Ok(actual == expected)
}
pub fn validate_against_manifest(
&self,
manifest: &crate::manifest::Manifest,
strict: bool,
) -> Result<Option<StalenessReason>> {
if let Some(reason) = self.detect_duplicate_entries()? {
return Ok(Some(reason));
}
for (source_name, manifest_url) in &manifest.sources {
if let Some(locked_source) = self.get_source(source_name)
&& &locked_source.url != manifest_url
{
return Ok(Some(StalenessReason::SourceUrlChanged {
name: source_name.clone(),
old_url: locked_source.url.clone(),
new_url: manifest_url.clone(),
}));
}
}
if strict {
for resource_type in crate::core::ResourceType::all() {
if let Some(manifest_deps) = manifest.get_dependencies(*resource_type) {
for (name, dep) in manifest_deps {
let locked_resource = self.get_resource(name);
if locked_resource.is_none() {
return Ok(Some(StalenessReason::MissingDependency {
name: name.clone(),
resource_type: *resource_type,
}));
}
if let Some(locked) = locked_resource {
if let Some(manifest_version) = dep.get_version()
&& let Some(locked_version) = &locked.version
&& manifest_version != locked_version
{
return Ok(Some(StalenessReason::VersionChanged {
name: name.clone(),
resource_type: *resource_type,
old_version: locked_version.clone(),
new_version: manifest_version.to_string(),
}));
}
if dep.get_path() != locked.path {
return Ok(Some(StalenessReason::PathChanged {
name: name.clone(),
resource_type: *resource_type,
old_path: locked.path.clone(),
new_path: dep.get_path().to_string(),
}));
}
let manifest_tool_string = dep
.get_tool()
.map(|s| s.to_string())
.unwrap_or_else(|| manifest.get_default_tool(*resource_type));
let manifest_tool = manifest_tool_string.as_str();
let locked_tool = locked.tool.as_deref().unwrap_or("claude-code");
if manifest_tool != locked_tool {
return Ok(Some(StalenessReason::ToolChanged {
name: name.clone(),
resource_type: *resource_type,
old_tool: locked_tool.to_string(),
new_tool: manifest_tool.to_string(),
}));
}
}
}
}
}
}
Ok(None)
}
pub fn is_stale(&self, manifest: &crate::manifest::Manifest, strict: bool) -> Result<bool> {
Ok(self.validate_against_manifest(manifest, strict)?.is_some())
}
fn detect_duplicate_entries(&self) -> Result<Option<StalenessReason>> {
use std::collections::HashMap;
for resource_type in crate::core::ResourceType::all() {
let resources = self.get_resources(*resource_type);
let mut seen_names = HashMap::new();
for resource in resources {
if let Some(_first_index) = seen_names.get(&resource.name) {
return Ok(Some(StalenessReason::DuplicateEntries {
name: resource.name.clone(),
resource_type: *resource_type,
count: resources.iter().filter(|r| r.name == resource.name).count(),
}));
}
seen_names.insert(&resource.name, 0);
}
}
Ok(None)
}
pub fn validate_no_duplicates(&self, path: &Path) -> Result<()> {
use std::collections::HashMap;
let mut found_duplicates = false;
let mut error_messages = Vec::new();
for resource_type in crate::core::ResourceType::all() {
let resources = self.get_resources(*resource_type);
let mut name_counts = HashMap::new();
for resource in resources {
*name_counts.entry(&resource.name).or_insert(0) += 1;
}
let duplicates: Vec<_> = name_counts.iter().filter(|(_, count)| **count > 1).collect();
if !duplicates.is_empty() {
found_duplicates = true;
let dup_names: Vec<_> = duplicates
.iter()
.map(|(name, count)| format!("{} ({} times)", name, **count))
.collect();
error_messages.push(format!(" {}: {}", resource_type, dup_names.join(", ")));
}
}
if found_duplicates {
return Err(crate::core::AgpmError::Other {
message: format!(
"Lockfile corruption detected in {}:\nDuplicate resource names found:\n{}\n\n\
This indicates lockfile corruption. To fix:\n\
- Delete agpm.lock and run 'agpm install' to regenerate it\n\
- Or restore from a backup if available",
path.display(),
error_messages.join("\n")
),
}
.into());
}
Ok(())
}
#[must_use]
pub fn find_resource(
&self,
name: &str,
resource_type: crate::core::ResourceType,
) -> Option<&LockedResource> {
self.get_resources(resource_type).iter().find(|r| r.name == name)
}
#[must_use]
pub fn get_resources_by_type(
&self,
resource_type: crate::core::ResourceType,
) -> &[LockedResource] {
self.get_resources(resource_type)
}
pub fn update_resource_checksum(&mut self, name: &str, checksum: &str) -> bool {
for resource in &mut self.agents {
if resource.name == name {
resource.checksum = checksum.to_string();
return true;
}
}
for resource in &mut self.snippets {
if resource.name == name {
resource.checksum = checksum.to_string();
return true;
}
}
for resource in &mut self.commands {
if resource.name == name {
resource.checksum = checksum.to_string();
return true;
}
}
for resource in &mut self.scripts {
if resource.name == name {
resource.checksum = checksum.to_string();
return true;
}
}
for resource in &mut self.hooks {
if resource.name == name {
resource.checksum = checksum.to_string();
return true;
}
}
for resource in &mut self.mcp_servers {
if resource.name == name {
resource.checksum = checksum.to_string();
return true;
}
}
false
}
pub fn update_resource_applied_patches(
&mut self,
name: &str,
applied_patches: &crate::manifest::patches::AppliedPatches,
) -> bool {
let project_patches = applied_patches.project.clone();
for resource in &mut self.agents {
if resource.name == name {
resource.applied_patches = project_patches;
return true;
}
}
for resource in &mut self.snippets {
if resource.name == name {
resource.applied_patches = project_patches;
return true;
}
}
for resource in &mut self.commands {
if resource.name == name {
resource.applied_patches = project_patches;
return true;
}
}
for resource in &mut self.scripts {
if resource.name == name {
resource.applied_patches = project_patches;
return true;
}
}
for resource in &mut self.hooks {
if resource.name == name {
resource.applied_patches = project_patches;
return true;
}
}
for resource in &mut self.mcp_servers {
if resource.name == name {
resource.applied_patches = project_patches;
return true;
}
}
false
}
}
impl Default for LockFile {
fn default() -> Self {
Self::new()
}
}
#[must_use]
pub fn find_lockfile() -> Option<PathBuf> {
let mut current = std::env::current_dir().ok()?;
loop {
let lockfile_path = current.join("agpm.lock");
if lockfile_path.exists() {
return Some(lockfile_path);
}
if !current.pop() {
return None;
}
}
}
pub mod private_lock;
pub use private_lock::PrivateLockFile;
#[allow(dead_code)]
pub mod patch_display;
#[cfg(test)]
mod tests {
use super::*;
use tempfile::tempdir;
#[test]
fn test_lockfile_new() {
let lockfile = LockFile::new();
assert_eq!(lockfile.version, LockFile::CURRENT_VERSION);
assert!(lockfile.sources.is_empty());
assert!(lockfile.agents.is_empty());
}
#[test]
fn test_lockfile_save_load() {
let temp = tempdir().unwrap();
let lockfile_path = temp.path().join("agpm.lock");
let mut lockfile = LockFile::new();
lockfile.add_source(
"official".to_string(),
"https://github.com/example-org/agpm-official.git".to_string(),
"abc123".to_string(),
);
lockfile.add_resource(
"test-agent".to_string(),
LockedResource {
name: "test-agent".to_string(),
source: Some("official".to_string()),
url: Some("https://github.com/example-org/agpm-official.git".to_string()),
path: "agents/test.md".to_string(),
version: Some("v1.0.0".to_string()),
resolved_commit: Some("abc123".to_string()),
checksum: "sha256:abcdef".to_string(),
installed_at: "agents/test-agent.md".to_string(),
dependencies: vec![],
resource_type: crate::core::ResourceType::Agent,
tool: Some("claude-code".to_string()),
manifest_alias: None,
applied_patches: std::collections::HashMap::new(),
install: None,
},
true,
);
lockfile.save(&lockfile_path).unwrap();
assert!(lockfile_path.exists());
let loaded = LockFile::load(&lockfile_path).unwrap();
assert_eq!(loaded.version, LockFile::CURRENT_VERSION);
assert_eq!(loaded.sources.len(), 1);
assert_eq!(loaded.agents.len(), 1);
assert_eq!(
loaded.get_source("official").unwrap().url,
"https://github.com/example-org/agpm-official.git"
);
assert_eq!(loaded.get_resource("test-agent").unwrap().checksum, "sha256:abcdef");
}
#[test]
fn test_staleness_reason_display() {
use crate::core::ResourceType;
let reason = StalenessReason::SourceUrlChanged {
name: "community".to_string(),
old_url: "https://github.com/old/repo.git".to_string(),
new_url: "https://github.com/new/repo.git".to_string(),
};
assert_eq!(
reason.to_string(),
"Source repository 'community' URL changed from 'https://github.com/old/repo.git' to 'https://github.com/new/repo.git'"
);
let reason = StalenessReason::DuplicateEntries {
name: "dup-agent".to_string(),
resource_type: ResourceType::Agent,
count: 3,
};
assert_eq!(
reason.to_string(),
"Found 3 duplicate entries for dependency 'dup-agent' (agent)"
);
}
#[test]
fn test_lockfile_empty_file() {
let temp = tempdir().unwrap();
let lockfile_path = temp.path().join("agpm.lock");
std::fs::write(&lockfile_path, "").unwrap();
let lockfile = LockFile::load(&lockfile_path).unwrap();
assert_eq!(lockfile.version, LockFile::CURRENT_VERSION);
assert!(lockfile.sources.is_empty());
}
#[test]
fn test_lockfile_version_check() {
let temp = tempdir().unwrap();
let lockfile_path = temp.path().join("agpm.lock");
let content = "version = 999\n";
std::fs::write(&lockfile_path, content).unwrap();
let result = LockFile::load(&lockfile_path);
assert!(result.is_err());
assert!(result.unwrap_err().to_string().contains("newer than supported"));
}
#[test]
fn test_resource_operations() {
let mut lockfile = LockFile::new();
lockfile.add_resource(
"agent1".to_string(),
LockedResource {
name: "agent1".to_string(),
source: None,
url: None,
path: "local/agent1.md".to_string(),
version: None,
resolved_commit: None,
checksum: "sha256:111".to_string(),
installed_at: "agents/agent1.md".to_string(),
dependencies: vec![],
resource_type: crate::core::ResourceType::Agent,
tool: Some("claude-code".to_string()),
manifest_alias: None,
applied_patches: std::collections::HashMap::new(),
install: None,
},
true, );
lockfile.add_resource(
"snippet1".to_string(),
LockedResource {
name: "snippet1".to_string(),
source: None,
url: None,
path: "local/snippet1.md".to_string(),
version: None,
resolved_commit: None,
checksum: "sha256:222".to_string(),
installed_at: "snippets/snippet1.md".to_string(),
dependencies: vec![],
resource_type: crate::core::ResourceType::Snippet,
tool: Some("claude-code".to_string()),
manifest_alias: None,
applied_patches: std::collections::HashMap::new(),
install: None,
},
false, );
lockfile.add_resource(
"dev-agent1".to_string(),
LockedResource {
name: "dev-agent1".to_string(),
source: None,
url: None,
path: "local/dev-agent1.md".to_string(),
version: None,
resolved_commit: None,
checksum: "sha256:333".to_string(),
installed_at: "agents/dev-agent1.md".to_string(),
dependencies: vec![],
resource_type: crate::core::ResourceType::Agent,
tool: Some("claude-code".to_string()),
manifest_alias: None,
applied_patches: std::collections::HashMap::new(),
install: None,
},
true, );
assert!(lockfile.has_resource("agent1"));
assert!(lockfile.has_resource("snippet1"));
assert!(lockfile.has_resource("dev-agent1"));
assert!(!lockfile.has_resource("nonexistent"));
assert_eq!(lockfile.all_resources().len(), 3);
lockfile.clear();
assert!(lockfile.all_resources().is_empty());
}
#[test]
fn test_checksum_computation() {
let temp = tempdir().unwrap();
let file_path = temp.path().join("test.md");
std::fs::write(&file_path, "Hello, World!").unwrap();
let checksum = LockFile::compute_checksum(&file_path).unwrap();
assert!(checksum.starts_with("sha256:"));
assert!(LockFile::verify_checksum(&file_path, &checksum).unwrap());
assert!(!LockFile::verify_checksum(&file_path, "sha256:wrong").unwrap());
}
#[test]
fn test_lockfile_with_commands() {
let mut lockfile = LockFile::new();
lockfile.add_typed_resource(
"build".to_string(),
LockedResource {
name: "build".to_string(),
source: Some("community".to_string()),
url: Some("https://github.com/example/community.git".to_string()),
path: "commands/build.md".to_string(),
version: Some("v1.0.0".to_string()),
resolved_commit: Some("abc123".to_string()),
checksum: "sha256:cmd123".to_string(),
installed_at: ".claude/commands/build.md".to_string(),
dependencies: vec![],
resource_type: crate::core::ResourceType::Command,
tool: Some("claude-code".to_string()),
manifest_alias: None,
applied_patches: std::collections::HashMap::new(),
install: None,
},
crate::core::ResourceType::Command,
);
assert_eq!(lockfile.commands.len(), 1);
assert!(lockfile.has_resource("build"));
let resource = lockfile.get_resource("build").unwrap();
assert_eq!(resource.name, "build");
assert_eq!(resource.installed_at, ".claude/commands/build.md");
}
#[test]
fn test_lockfile_all_resources_with_commands() {
let mut lockfile = LockFile::new();
lockfile.add_resource(
"agent1".to_string(),
LockedResource {
name: "agent1".to_string(),
source: None,
url: None,
path: "agent1.md".to_string(),
version: None,
resolved_commit: None,
checksum: "sha256:a1".to_string(),
installed_at: "agents/agent1.md".to_string(),
dependencies: vec![],
resource_type: crate::core::ResourceType::Agent,
tool: Some("claude-code".to_string()),
manifest_alias: None,
applied_patches: std::collections::HashMap::new(),
install: None,
},
true,
);
lockfile.add_resource(
"snippet1".to_string(),
LockedResource {
name: "snippet1".to_string(),
source: None,
url: None,
path: "snippet1.md".to_string(),
version: None,
resolved_commit: None,
checksum: "sha256:s1".to_string(),
installed_at: "snippets/snippet1.md".to_string(),
dependencies: vec![],
resource_type: crate::core::ResourceType::Snippet,
tool: Some("claude-code".to_string()),
manifest_alias: None,
applied_patches: std::collections::HashMap::new(),
install: None,
},
false,
);
lockfile.add_typed_resource(
"command1".to_string(),
LockedResource {
name: "command1".to_string(),
source: None,
url: None,
path: "command1.md".to_string(),
version: None,
resolved_commit: None,
checksum: "sha256:c1".to_string(),
installed_at: ".claude/commands/command1.md".to_string(),
dependencies: vec![],
resource_type: crate::core::ResourceType::Command,
tool: Some("claude-code".to_string()),
manifest_alias: None,
applied_patches: std::collections::HashMap::new(),
install: None,
},
crate::core::ResourceType::Command,
);
let all = lockfile.all_resources();
assert_eq!(all.len(), 3);
lockfile.clear();
assert!(lockfile.agents.is_empty());
assert!(lockfile.snippets.is_empty());
assert!(lockfile.commands.is_empty());
}
#[test]
fn test_lockfile_save_load_commands() {
let temp = tempdir().unwrap();
let lockfile_path = temp.path().join("agpm.lock");
let mut lockfile = LockFile::new();
lockfile.add_typed_resource(
"deploy".to_string(),
LockedResource {
name: "deploy".to_string(),
source: Some("official".to_string()),
url: Some("https://github.com/example/official.git".to_string()),
path: "commands/deploy.md".to_string(),
version: Some("v2.0.0".to_string()),
resolved_commit: Some("def456".to_string()),
checksum: "sha256:deploy123".to_string(),
installed_at: ".claude/commands/deploy.md".to_string(),
dependencies: vec![],
resource_type: crate::core::ResourceType::Command,
tool: Some("claude-code".to_string()),
manifest_alias: None,
applied_patches: std::collections::HashMap::new(),
install: None,
},
crate::core::ResourceType::Command,
);
lockfile.save(&lockfile_path).unwrap();
let loaded = LockFile::load(&lockfile_path).unwrap();
assert_eq!(loaded.commands.len(), 1);
assert!(loaded.has_resource("deploy"));
let cmd = &loaded.commands[0];
assert_eq!(cmd.name, "deploy");
assert_eq!(cmd.version, Some("v2.0.0".to_string()));
assert_eq!(cmd.installed_at, ".claude/commands/deploy.md");
}
#[test]
fn test_lockfile_get_resource_precedence() {
let mut lockfile = LockFile::new();
lockfile.add_resource(
"helper".to_string(),
LockedResource {
name: "helper".to_string(),
source: None,
url: None,
path: "agent_helper.md".to_string(),
version: None,
resolved_commit: None,
checksum: "sha256:agent".to_string(),
installed_at: "agents/helper.md".to_string(),
dependencies: vec![],
resource_type: crate::core::ResourceType::Agent,
tool: Some("claude-code".to_string()),
manifest_alias: None,
applied_patches: std::collections::HashMap::new(),
install: None,
},
true,
);
lockfile.add_typed_resource(
"helper".to_string(),
LockedResource {
name: "helper".to_string(),
source: None,
url: None,
path: "command_helper.md".to_string(),
version: None,
resolved_commit: None,
checksum: "sha256:command".to_string(),
installed_at: ".claude/commands/helper.md".to_string(),
dependencies: vec![],
resource_type: crate::core::ResourceType::Command,
tool: Some("claude-code".to_string()),
manifest_alias: None,
applied_patches: std::collections::HashMap::new(),
install: None,
},
crate::core::ResourceType::Command,
);
let resource = lockfile.get_resource("helper").unwrap();
assert_eq!(resource.installed_at, "agents/helper.md");
}
}