pub mod dependency_spec;
pub mod helpers;
pub mod patches;
pub mod resource_dependency;
pub mod tool_config;
#[cfg(test)]
mod manifest_tests;
#[cfg(test)]
mod tool_config_tests;
use crate::core::file_error::{FileOperation, FileResultExt};
use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap};
use std::path::{Path, PathBuf};
pub use dependency_spec::{DependencyMetadata, DependencySpec};
pub use helpers::{expand_url, find_manifest, find_manifest_from, find_manifest_with_optional};
pub use patches::{ManifestPatches, PatchConflict, PatchData, PatchOrigin};
pub use resource_dependency::{DetailedDependency, ResourceDependency};
pub use tool_config::{ArtifactTypeConfig, ResourceConfig, ToolsConfig, WellKnownTool};
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ProjectConfig(toml::map::Map<String, toml::Value>);
impl ProjectConfig {
pub fn to_json_value(&self) -> serde_json::Value {
toml_value_to_json(&toml::Value::Table(self.0.clone()))
}
}
impl From<toml::map::Map<String, toml::Value>> for ProjectConfig {
fn from(map: toml::map::Map<String, toml::Value>) -> Self {
Self(map)
}
}
pub(crate) fn toml_value_to_json(value: &toml::Value) -> serde_json::Value {
match value {
toml::Value::String(s) => serde_json::Value::String(s.clone()),
toml::Value::Integer(i) => serde_json::Value::Number((*i).into()),
toml::Value::Float(f) => serde_json::Number::from_f64(*f)
.map(serde_json::Value::Number)
.unwrap_or(serde_json::Value::Null),
toml::Value::Boolean(b) => serde_json::Value::Bool(*b),
toml::Value::Datetime(dt) => serde_json::Value::String(dt.to_string()),
toml::Value::Array(arr) => {
serde_json::Value::Array(arr.iter().map(toml_value_to_json).collect())
}
toml::Value::Table(table) => {
let mut keys: Vec<_> = table.keys().collect();
keys.sort();
let map: serde_json::Map<String, serde_json::Value> =
keys.into_iter().map(|k| (k.clone(), toml_value_to_json(&table[k]))).collect();
serde_json::Value::Object(map)
}
}
}
#[cfg(test)]
pub(crate) fn json_value_to_toml(value: &serde_json::Value) -> toml::Value {
match value {
serde_json::Value::String(s) => toml::Value::String(s.clone()),
serde_json::Value::Number(n) => {
if let Some(i) = n.as_i64() {
toml::Value::Integer(i)
} else if let Some(f) = n.as_f64() {
toml::Value::Float(f)
} else {
toml::Value::String(n.to_string())
}
}
serde_json::Value::Bool(b) => toml::Value::Boolean(*b),
serde_json::Value::Null => {
toml::Value::String(String::new())
}
serde_json::Value::Array(arr) => {
toml::Value::Array(arr.iter().map(json_value_to_toml).collect())
}
serde_json::Value::Object(obj) => {
let table: toml::map::Map<String, toml::Value> =
obj.iter().map(|(k, v)| (k.clone(), json_value_to_toml(v))).collect();
toml::Value::Table(table)
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Manifest {
#[serde(default, skip_serializing_if = "HashMap::is_empty")]
pub sources: HashMap<String, String>,
#[serde(rename = "tools", skip_serializing_if = "Option::is_none")]
pub tools: Option<ToolsConfig>,
#[serde(default, skip_serializing_if = "HashMap::is_empty")]
pub agents: HashMap<String, ResourceDependency>,
#[serde(default, skip_serializing_if = "HashMap::is_empty")]
pub snippets: HashMap<String, ResourceDependency>,
#[serde(default, skip_serializing_if = "HashMap::is_empty")]
pub commands: HashMap<String, ResourceDependency>,
#[serde(default, skip_serializing_if = "HashMap::is_empty", rename = "mcp-servers")]
pub mcp_servers: HashMap<String, ResourceDependency>,
#[serde(default, skip_serializing_if = "HashMap::is_empty")]
pub scripts: HashMap<String, ResourceDependency>,
#[serde(default, skip_serializing_if = "HashMap::is_empty")]
pub hooks: HashMap<String, ResourceDependency>,
#[serde(default, skip_serializing_if = "ManifestPatches::is_empty", rename = "patch")]
pub patches: ManifestPatches,
#[serde(skip)]
pub project_patches: ManifestPatches,
#[serde(skip)]
pub private_patches: ManifestPatches,
#[serde(default, skip_serializing_if = "HashMap::is_empty", rename = "default-tools")]
pub default_tools: HashMap<String, String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub project: Option<ProjectConfig>,
#[serde(skip)]
pub manifest_dir: Option<std::path::PathBuf>,
}
impl Manifest {
#[must_use]
#[allow(deprecated)]
pub fn new() -> Self {
Self {
sources: HashMap::new(),
tools: None,
agents: HashMap::new(),
snippets: HashMap::new(),
commands: HashMap::new(),
mcp_servers: HashMap::new(),
scripts: HashMap::new(),
hooks: HashMap::new(),
patches: ManifestPatches::new(),
project_patches: ManifestPatches::new(),
private_patches: ManifestPatches::new(),
default_tools: HashMap::new(),
project: None,
manifest_dir: None,
}
}
pub fn load(path: &Path) -> Result<Self> {
let content = std::fs::read_to_string(path).with_file_context(
FileOperation::Read,
path,
"reading manifest file",
"manifest_module",
)?;
let mut manifest: Self = toml::from_str(&content)
.map_err(|e| crate::core::AgpmError::ManifestParseError {
file: path.display().to_string(),
reason: e.to_string(),
})
.with_context(|| {
format!(
"Invalid TOML syntax in manifest file: {}\n\n\
Common TOML syntax errors:\n\
- Missing quotes around strings\n\
- Unmatched brackets [ ] or braces {{ }}\n\
- Invalid characters in keys or values\n\
- Incorrect indentation or structure",
path.display()
)
})?;
manifest.apply_tool_defaults();
manifest.manifest_dir = Some(
path.parent()
.ok_or_else(|| anyhow::anyhow!("Manifest path has no parent directory"))?
.to_path_buf(),
);
manifest.validate()?;
Ok(manifest)
}
pub fn load_with_private(path: &Path) -> Result<(Self, Vec<PatchConflict>)> {
let mut manifest = Self::load(path)?;
manifest.project_patches = manifest.patches.clone();
let private_path = if let Some(parent) = path.parent() {
parent.join("agpm.private.toml")
} else {
PathBuf::from("agpm.private.toml")
};
if private_path.exists() {
let private_manifest = Self::load_private(&private_path)?;
manifest.private_patches = private_manifest.patches.clone();
let (merged_patches, conflicts) =
manifest.patches.merge_with(&private_manifest.patches);
manifest.patches = merged_patches;
Ok((manifest, conflicts))
} else {
manifest.private_patches = ManifestPatches::new();
Ok((manifest, Vec::new()))
}
}
fn load_private(path: &Path) -> Result<Self> {
let content = std::fs::read_to_string(path).with_file_context(
FileOperation::Read,
path,
"reading private manifest file",
"manifest_module",
)?;
let manifest: Self = toml::from_str(&content)
.map_err(|e| crate::core::AgpmError::ManifestParseError {
file: path.display().to_string(),
reason: e.to_string(),
})
.with_context(|| {
format!(
"Invalid TOML syntax in private manifest file: {}\n\n\
Common TOML syntax errors:\n\
- Missing quotes around strings\n\
- Unmatched brackets [ ] or braces {{ }}\n\
- Invalid characters in keys or values\n\
- Incorrect indentation or structure",
path.display()
)
})?;
if !manifest.sources.is_empty()
|| manifest.tools.is_some()
|| !manifest.agents.is_empty()
|| !manifest.snippets.is_empty()
|| !manifest.commands.is_empty()
|| !manifest.mcp_servers.is_empty()
|| !manifest.scripts.is_empty()
|| !manifest.hooks.is_empty()
{
anyhow::bail!(
"Private manifest file ({}) can only contain [patch] sections, not sources, tools, or dependencies",
path.display()
);
}
Ok(manifest)
}
#[must_use]
pub fn get_default_tool(&self, resource_type: crate::core::ResourceType) -> String {
let resource_name = match resource_type {
crate::core::ResourceType::Agent => "agents",
crate::core::ResourceType::Snippet => "snippets",
crate::core::ResourceType::Command => "commands",
crate::core::ResourceType::Script => "scripts",
crate::core::ResourceType::Hook => "hooks",
crate::core::ResourceType::McpServer => "mcp-servers",
};
if let Some(tool) = self.default_tools.get(resource_name) {
return tool.clone();
}
resource_type.default_tool().to_string()
}
fn apply_tool_defaults(&mut self) {
for resource_type in [
crate::core::ResourceType::Snippet,
crate::core::ResourceType::Agent,
crate::core::ResourceType::Command,
crate::core::ResourceType::Script,
crate::core::ResourceType::Hook,
crate::core::ResourceType::McpServer,
] {
let default_tool = self.get_default_tool(resource_type);
if let Some(deps) = self.get_dependencies_mut(resource_type) {
for dependency in deps.values_mut() {
if let ResourceDependency::Detailed(details) = dependency {
if details.tool.is_none() {
details.tool = Some(default_tool.clone());
}
}
}
}
}
}
pub fn save(&self, path: &Path) -> Result<()> {
let mut doc = toml_edit::ser::to_document(self)
.with_context(|| "Failed to serialize manifest data to TOML format")?;
for (_key, value) in doc.iter_mut() {
if let Some(inline_table) = value.as_inline_table() {
let table = inline_table.clone().into_table();
*value = toml_edit::Item::Table(table);
}
}
let content = doc.to_string();
std::fs::write(path, content).with_file_context(
FileOperation::Write,
path,
"writing manifest file",
"manifest_module",
)?;
Ok(())
}
pub fn validate(&self) -> Result<()> {
for artifact_type in self.get_tools_config().types.keys() {
if artifact_type.contains('/') || artifact_type.contains('\\') {
return Err(crate::core::AgpmError::ManifestValidationError {
reason: format!(
"Artifact type name '{artifact_type}' cannot contain path separators ('/' or '\\\\'). \n\
Artifact type names must be simple identifiers without special characters."
),
}
.into());
}
if artifact_type.contains("..") {
return Err(crate::core::AgpmError::ManifestValidationError {
reason: format!(
"Artifact type name '{artifact_type}' cannot contain '..' (path traversal). \n\
Artifact type names must be simple identifiers."
),
}
.into());
}
}
for (name, dep) in self.all_dependencies() {
if dep.get_path().is_empty() {
return Err(crate::core::AgpmError::ManifestValidationError {
reason: format!("Missing required field 'path' for dependency '{name}'"),
}
.into());
}
if dep.is_pattern() {
crate::pattern::validate_pattern_safety(dep.get_path()).map_err(|e| {
crate::core::AgpmError::ManifestValidationError {
reason: format!("Invalid pattern in dependency '{name}': {e}"),
}
})?;
}
if let Some(source) = dep.get_source() {
if !self.sources.contains_key(source) {
return Err(crate::core::AgpmError::SourceNotFound {
name: source.to_string(),
}
.into());
}
let source_url = self.sources.get(source).unwrap();
let _is_local_source = source_url.starts_with('/')
|| source_url.starts_with("./")
|| source_url.starts_with("../");
} else {
if !dep.is_pattern() {
let path = dep.get_path();
let is_plain_dir =
path.starts_with('/') || path.starts_with("./") || path.starts_with("../");
if is_plain_dir && dep.get_version().is_some() {
return Err(crate::core::AgpmError::ManifestValidationError {
reason: format!(
"Version specified for plain directory dependency '{name}' with path '{path}'. \n\
Plain directory dependencies do not support versions. \n\
Remove the 'version' field or use a git source instead."
),
}
.into());
}
}
}
}
let mut seen_deps: std::collections::HashMap<String, String> =
std::collections::HashMap::new();
for (name, dep) in self.all_dependencies() {
if let Some(version) = dep.get_version() {
if let Some(existing_version) = seen_deps.get(name) {
if existing_version != version {
return Err(crate::core::AgpmError::ManifestValidationError {
reason: format!(
"Version conflict for dependency '{name}': found versions '{existing_version}' and '{version}'"
),
}
.into());
}
} else {
seen_deps.insert(name.to_string(), version.to_string());
}
}
}
for (name, url) in &self.sources {
let expanded_url = expand_url(url)?;
if !expanded_url.starts_with("http://")
&& !expanded_url.starts_with("https://")
&& !expanded_url.starts_with("git@")
&& !expanded_url.starts_with("file://")
&& !expanded_url.starts_with('/')
&& !expanded_url.starts_with("./")
&& !expanded_url.starts_with("../")
{
return Err(crate::core::AgpmError::ManifestValidationError {
reason: format!("Source '{name}' has invalid URL: '{url}'. Must be HTTP(S), SSH (git@...), or file:// URL"),
}
.into());
}
if expanded_url.starts_with('/')
|| expanded_url.starts_with("./")
|| expanded_url.starts_with("../")
{
return Err(crate::core::AgpmError::ManifestValidationError {
reason: format!(
"Plain directory path '{url}' cannot be used as source '{name}'. \n\
Sources must be git repositories. Use one of:\n\
- Remote URL: https://github.com/owner/repo.git\n\
- Local git repo: file:///absolute/path/to/repo\n\
- Or use direct path dependencies without a source"
),
}
.into());
}
}
let mut normalized_names: std::collections::HashSet<String> =
std::collections::HashSet::new();
for (name, _) in self.all_dependencies() {
let normalized = name.to_lowercase();
if !normalized_names.insert(normalized.clone()) {
for (other_name, _) in self.all_dependencies() {
if other_name != name && other_name.to_lowercase() == normalized {
return Err(crate::core::AgpmError::ManifestValidationError {
reason: format!(
"Case conflict: '{name}' and '{other_name}' would map to the same file on case-insensitive filesystems. To ensure portability across platforms, resource names must be case-insensitively unique."
),
}
.into());
}
}
}
}
for resource_type in crate::core::ResourceType::all() {
if let Some(deps) = self.get_dependencies(*resource_type) {
for (name, dep) in deps {
let tool_string = dep
.get_tool()
.map(|s| s.to_string())
.unwrap_or_else(|| self.get_default_tool(*resource_type));
let tool = tool_string.as_str();
if self.get_tool_config(tool).is_none() {
return Err(crate::core::AgpmError::ManifestValidationError {
reason: format!(
"Unknown tool '{tool}' for dependency '{name}'.\n\
Available types: {}\n\
Configure custom types in [tools] section or use a standard type.",
self.get_tools_config()
.types
.keys()
.map(|s| format!("'{s}'"))
.collect::<Vec<_>>()
.join(", ")
),
}
.into());
}
if !self.is_resource_supported(tool, *resource_type) {
let artifact_config = self.get_tool_config(tool).unwrap();
let resource_plural = resource_type.to_plural();
let is_malformed = artifact_config.resources.contains_key(resource_plural);
let supported_types: Vec<String> = artifact_config
.resources
.iter()
.filter(|(_, res_config)| {
res_config.path.is_some() || res_config.merge_target.is_some()
})
.map(|(s, _)| s.to_string())
.collect();
let mut suggestions = Vec::new();
if is_malformed {
suggestions.push(format!(
"Resource type '{}' is configured for tool '{}' but missing required 'path' or 'merge_target' field",
resource_plural, tool
));
match resource_type {
crate::core::ResourceType::Hook => {
suggestions.push("For hooks, add: merge_target = '.claude/settings.local.json'".to_string());
}
crate::core::ResourceType::McpServer => {
suggestions.push(
"For MCP servers, add: merge_target = '.mcp.json'"
.to_string(),
);
}
_ => {
suggestions.push(format!(
"For {}, add: path = '{}'",
resource_plural, resource_plural
));
}
}
} else {
match resource_type {
crate::core::ResourceType::Snippet => {
suggestions.push("Snippets work best with the 'agpm' tool (shared infrastructure)".to_string());
suggestions.push(
"Add tool='agpm' to this dependency to use shared snippets"
.to_string(),
);
}
_ => {
let default_config = ToolsConfig::default();
let tools_config =
self.tools.as_ref().unwrap_or(&default_config);
let supporting_types: Vec<String> = tools_config
.types
.iter()
.filter(|(_, config)| {
config.resources.contains_key(resource_plural)
&& config
.resources
.get(resource_plural)
.map(|res| {
res.path.is_some()
|| res.merge_target.is_some()
})
.unwrap_or(false)
})
.map(|(type_name, _)| format!("'{}'", type_name))
.collect();
if !supporting_types.is_empty() {
suggestions.push(format!(
"This resource type is supported by tools: {}",
supporting_types.join(", ")
));
}
}
}
}
let mut reason = if is_malformed {
format!(
"Resource type '{}' is improperly configured for tool '{}' for dependency '{}'.\n\n",
resource_plural, tool, name
)
} else {
format!(
"Resource type '{}' is not supported by tool '{}' for dependency '{}'.\n\n",
resource_plural, tool, name
)
};
reason.push_str(&format!(
"Tool '{}' properly supports: {}\n\n",
tool,
supported_types.join(", ")
));
if !suggestions.is_empty() {
reason.push_str("💡 Suggestions:\n");
for suggestion in &suggestions {
reason.push_str(&format!(" • {}\n", suggestion));
}
reason.push('\n');
}
reason.push_str(
"You can fix this by:\n\
1. Changing the 'tool' field to a supported tool\n\
2. Using a different resource type\n\
3. Removing this dependency from your manifest",
);
return Err(crate::core::AgpmError::ManifestValidationError {
reason,
}
.into());
}
}
}
}
self.validate_patches()?;
Ok(())
}
fn validate_patches(&self) -> Result<()> {
use crate::core::ResourceType;
let check_patch_aliases = |resource_type: ResourceType,
patches: &BTreeMap<String, PatchData>|
-> Result<()> {
let deps = self.get_dependencies(resource_type);
for alias in patches.keys() {
let exists = if let Some(deps) = deps {
deps.contains_key(alias)
} else {
false
};
if !exists {
return Err(crate::core::AgpmError::ManifestValidationError {
reason: format!(
"Patch references unknown alias '{alias}' in [patch.{}] section.\n\
The alias must be defined in [{}] section of agpm.toml.\n\
To patch a transitive dependency, first add it explicitly to your manifest.",
resource_type.to_plural(),
resource_type.to_plural()
),
}
.into());
}
}
Ok(())
};
check_patch_aliases(ResourceType::Agent, &self.patches.agents)?;
check_patch_aliases(ResourceType::Snippet, &self.patches.snippets)?;
check_patch_aliases(ResourceType::Command, &self.patches.commands)?;
check_patch_aliases(ResourceType::Script, &self.patches.scripts)?;
check_patch_aliases(ResourceType::McpServer, &self.patches.mcp_servers)?;
check_patch_aliases(ResourceType::Hook, &self.patches.hooks)?;
Ok(())
}
pub const fn get_dependencies(
&self,
resource_type: crate::core::ResourceType,
) -> Option<&HashMap<String, ResourceDependency>> {
use crate::core::ResourceType;
match resource_type {
ResourceType::Agent => Some(&self.agents),
ResourceType::Snippet => Some(&self.snippets),
ResourceType::Command => Some(&self.commands),
ResourceType::Script => Some(&self.scripts),
ResourceType::Hook => Some(&self.hooks),
ResourceType::McpServer => Some(&self.mcp_servers),
}
}
#[must_use]
pub fn get_dependencies_mut(
&mut self,
resource_type: crate::core::ResourceType,
) -> Option<&mut HashMap<String, ResourceDependency>> {
use crate::core::ResourceType;
match resource_type {
ResourceType::Agent => Some(&mut self.agents),
ResourceType::Snippet => Some(&mut self.snippets),
ResourceType::Command => Some(&mut self.commands),
ResourceType::Script => Some(&mut self.scripts),
ResourceType::Hook => Some(&mut self.hooks),
ResourceType::McpServer => Some(&mut self.mcp_servers),
}
}
pub fn get_tools_config(&self) -> &ToolsConfig {
self.tools.as_ref().unwrap_or_else(|| {
static DEFAULT: std::sync::OnceLock<ToolsConfig> = std::sync::OnceLock::new();
DEFAULT.get_or_init(ToolsConfig::default)
})
}
pub fn get_tool_config(&self, tool: &str) -> Option<&ArtifactTypeConfig> {
self.get_tools_config().types.get(tool)
}
pub fn get_artifact_resource_path(
&self,
tool: &str,
resource_type: crate::core::ResourceType,
) -> Option<std::path::PathBuf> {
let artifact_config = self.get_tool_config(tool)?;
let resource_config = artifact_config.resources.get(resource_type.to_plural())?;
resource_config.path.as_ref().map(|subdir| artifact_config.path.join(subdir))
}
pub fn get_merge_target(
&self,
tool: &str,
resource_type: crate::core::ResourceType,
) -> Option<PathBuf> {
let artifact_config = self.get_tool_config(tool)?;
let resource_config = artifact_config.resources.get(resource_type.to_plural())?;
resource_config.merge_target.as_ref().map(PathBuf::from)
}
pub fn is_resource_supported(
&self,
tool: &str,
resource_type: crate::core::ResourceType,
) -> bool {
self.get_tool_config(tool)
.and_then(|config| config.resources.get(resource_type.to_plural()))
.map(|res_config| res_config.path.is_some() || res_config.merge_target.is_some())
.unwrap_or(false)
}
#[must_use]
pub fn all_dependencies(&self) -> Vec<(&str, &ResourceDependency)> {
let mut deps = Vec::new();
for resource_type in crate::core::ResourceType::all() {
if let Some(type_deps) = self.get_dependencies(*resource_type) {
let mut sorted_deps: Vec<_> = type_deps.iter().collect();
sorted_deps.sort_by_key(|(name, _)| name.as_str());
for (name, dep) in sorted_deps {
deps.push((name.as_str(), dep));
}
}
}
deps
}
#[must_use]
pub fn all_dependencies_with_mcp(
&self,
) -> Vec<(&str, std::borrow::Cow<'_, ResourceDependency>)> {
let mut deps = Vec::new();
for resource_type in crate::core::ResourceType::all() {
if let Some(type_deps) = self.get_dependencies(*resource_type) {
let mut sorted_deps: Vec<_> = type_deps.iter().collect();
sorted_deps.sort_by_key(|(name, _)| name.as_str());
for (name, dep) in sorted_deps {
deps.push((name.as_str(), std::borrow::Cow::Borrowed(dep)));
}
}
}
deps
}
pub fn all_dependencies_with_types(
&self,
) -> Vec<(&str, std::borrow::Cow<'_, ResourceDependency>, crate::core::ResourceType)> {
let mut deps = Vec::new();
for resource_type in crate::core::ResourceType::all() {
if let Some(type_deps) = self.get_dependencies(*resource_type) {
let mut sorted_deps: Vec<_> = type_deps.iter().collect();
sorted_deps.sort_by_key(|(name, _)| name.as_str());
for (name, dep) in sorted_deps {
let tool_string = dep
.get_tool()
.map(|s| s.to_string())
.unwrap_or_else(|| self.get_default_tool(*resource_type));
let tool = tool_string.as_str();
if let Some(tool_config) = self.get_tools_config().types.get(tool) {
if !tool_config.enabled {
tracing::debug!(
"Skipping dependency '{}' for disabled tool '{}'",
name,
tool
);
continue;
}
}
let dep_with_tool = if dep.get_tool().is_none() {
tracing::debug!(
"Setting default tool '{}' for dependency '{}' (type: {:?})",
tool,
name,
resource_type
);
let mut dep_owned = dep.clone();
dep_owned.set_tool(Some(tool_string.clone()));
std::borrow::Cow::Owned(dep_owned)
} else {
std::borrow::Cow::Borrowed(dep)
};
deps.push((name.as_str(), dep_with_tool, *resource_type));
}
}
}
deps
}
#[must_use]
pub fn has_dependency(&self, name: &str) -> bool {
self.agents.contains_key(name)
|| self.snippets.contains_key(name)
|| self.commands.contains_key(name)
}
#[must_use]
pub fn get_dependency(&self, name: &str) -> Option<&ResourceDependency> {
self.agents
.get(name)
.or_else(|| self.snippets.get(name))
.or_else(|| self.commands.get(name))
}
pub fn find_dependency(&self, name: &str) -> Option<&ResourceDependency> {
self.get_dependency(name)
}
pub fn add_source(&mut self, name: String, url: String) {
self.sources.insert(name, url);
}
pub fn add_dependency(&mut self, name: String, dep: ResourceDependency, is_agent: bool) {
if is_agent {
self.agents.insert(name, dep);
} else {
self.snippets.insert(name, dep);
}
}
pub fn add_typed_dependency(
&mut self,
name: String,
dep: ResourceDependency,
resource_type: crate::core::ResourceType,
) {
match resource_type {
crate::core::ResourceType::Agent => {
self.agents.insert(name, dep);
}
crate::core::ResourceType::Snippet => {
self.snippets.insert(name, dep);
}
crate::core::ResourceType::Command => {
self.commands.insert(name, dep);
}
crate::core::ResourceType::McpServer => {
panic!("Use add_mcp_server() for MCP server dependencies");
}
crate::core::ResourceType::Script => {
self.scripts.insert(name, dep);
}
crate::core::ResourceType::Hook => {
self.hooks.insert(name, dep);
}
}
}
#[must_use]
pub fn get_resources(
&self,
resource_type: &crate::core::ResourceType,
) -> &HashMap<String, ResourceDependency> {
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,
}
}
#[must_use]
pub fn all_resources(&self) -> Vec<(crate::core::ResourceType, &str, &ResourceDependency)> {
use crate::core::ResourceType;
let mut resources = Vec::new();
for resource_type in ResourceType::all() {
let type_resources = self.get_resources(resource_type);
for (name, dep) in type_resources {
resources.push((*resource_type, name.as_str(), dep));
}
}
resources
}
pub fn add_mcp_server(&mut self, name: String, dependency: ResourceDependency) {
self.mcp_servers.insert(name, dependency);
}
}
impl Default for Manifest {
fn default() -> Self {
Self::new()
}
}