Struct ProjectConfig 

pub struct ProjectConfig(/* private fields */);

The main manifest file structure representing a complete agpm.toml file.

This struct encapsulates all configuration for a AGPM project, including source repositories, installation targets, and resource dependencies. It provides the foundation for declarative dependency management similar to Cargo’s Cargo.toml.

Structure

• Sources: Named Git repositories that can be referenced by dependencies
• Target: Installation directories for different resource types
• Agents: AI agent dependencies (.md files with agent definitions)
• Snippets: Code snippet dependencies (.md files with reusable code)
• Commands: Claude Code command dependencies (.md files with slash commands)

Serialization

The struct uses Serde for TOML serialization/deserialization with these behaviors:

• Empty collections are omitted from serialized output for cleaner files
• Default values are automatically applied for missing fields
• Field names match TOML section names exactly

Thread Safety

This struct is thread-safe and can be shared across async tasks safely.

Examples

use agpm_cli::manifest::{Manifest, ResourceDependency};

// Create a new empty manifest
let mut manifest = Manifest::new();

// Add a source repository
manifest.add_source(
    "community".to_string(),
    "https://github.com/claude-community/resources.git".to_string()
);

// Add a dependency
manifest.add_dependency(
    "helper".to_string(),
    ResourceDependency::Simple("../local/helper.md".to_string()),
    true  // is_agent = true
);

Project-specific template variables for AI coding assistants.

An arbitrary map of user-defined variables that can be referenced in resource templates. This provides maximum flexibility for teams to organize project context however they want, without imposing any predefined structure.

Use Case: AI Agent Context

When AI agents work on your codebase, they need context about:

• Where to find coding standards and style guides
• What conventions to follow (formatting, naming, patterns)
• Where architecture and design docs are located
• Project-specific requirements (testing, security, performance)

Template Access

All variables are accessible in templates under the agpm.project namespace. The structure is completely user-defined.

Examples

Flexible Structure - Organize However You Want

[project]
# Top-level variables
style_guide = "docs/STYLE_GUIDE.md"
max_line_length = 100
test_framework = "pytest"

# Nested sections (optional, just for organization)
[project.paths]
architecture = "docs/ARCHITECTURE.md"
conventions = "docs/CONVENTIONS.md"

[project.standards]
indent_style = "spaces"
indent_size = 4

Template Usage

# Code Reviewer
Follow guidelines at: {{ agpm.project.style_guide }}
Max line length: {{ agpm.project.max_line_length }}
Architecture: {{ agpm.project.paths.architecture }}

Any Structure Works

[project]
whatever = "you want"
numbers = 42
arrays = ["work", "too"]

[project.deeply.nested.structure]
is_allowed = true

Implementations

impl ProjectConfig

pub fn to_json_value(&self) -> Value

Convert this ProjectConfig to a serde_json::Value for template rendering.

This method handles conversion of TOML values to JSON values, which is necessary for proper Tera template rendering.

Examples

use agpm_cli::manifest::ProjectConfig;

let mut config_map = toml::map::Map::new();
config_map.insert("style_guide".to_string(), toml::Value::String("docs/STYLE.md".into()));
let config = ProjectConfig::from(config_map);

let json = config.to_json_value();
// Use json in Tera template context

Trait Implementations

impl Clone for ProjectConfig

fn clone(&self) -> ProjectConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProjectConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ProjectConfig

fn default() -> ProjectConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ProjectConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Map<String, Value>> for ProjectConfig

fn from(map: Map<String, Value>) -> Self

Converts to this type from the input type.

impl Serialize for ProjectConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.