Struct PrivateLockFile 

pub struct PrivateLockFile {
    pub version: u32,
    pub agents: Vec<LockedResource>,
    pub snippets: Vec<LockedResource>,
    pub commands: Vec<LockedResource>,
    pub scripts: Vec<LockedResource>,
    pub mcp_servers: Vec<LockedResource>,
    pub hooks: Vec<LockedResource>,
    pub skills: Vec<LockedResource>,
}

Private lockfile tracking user-level dependencies.

This file is gitignored and contains full LockedResource entries for dependencies that came from agpm.private.toml. It works alongside agpm.lock to provide full reproducibility while keeping team lockfiles deterministic.

Uses the same array-based format as agpm.lock for consistency.

Fields

version: u32

Lockfile format version

agents: Vec<LockedResource>

Private agents

snippets: Vec<LockedResource>

Private snippets

commands: Vec<LockedResource>

Private commands

scripts: Vec<LockedResource>

Private scripts

mcp_servers: Vec<LockedResource>

Private MCP servers

hooks: Vec<LockedResource>

Private hooks

skills: Vec<LockedResource>

Private skills

Implementations

impl PrivateLockFile

pub fn new() -> Self

Create a new empty private lockfile.

pub fn load(project_dir: &Path) -> Result<Option<Self>>

Load private lockfile from disk.

Returns Ok(None) if the file doesn’t exist (no private resources).

Example

use agpm_cli::lockfile::private_lock::PrivateLockFile;
use std::path::Path;

let project_dir = Path::new(".");
match PrivateLockFile::load(project_dir)? {
    Some(lock) => println!("Loaded {} private resources", lock.total_resources()),
    None => println!("No private lockfile found"),
}

pub fn save(&self, project_dir: &Path) -> Result<()>

Save private lockfile to disk.

Deletes the file if the lockfile is empty (no private resources).

Example

use agpm_cli::lockfile::private_lock::PrivateLockFile;
use std::path::Path;

let lock = PrivateLockFile::new();
lock.save(Path::new("."))?;

pub fn is_empty(&self) -> bool

Check if the lockfile has any private resources.

pub fn total_resources(&self) -> usize

Count total number of private resources.

pub fn all_resources(&self) -> Vec<&LockedResource>

Get all resources from the private lockfile.

pub fn from_resources(resources: Vec<LockedResource>) -> Self

Create a private lockfile from a vector of private resources.

Filters and distributes resources into appropriate type vectors.

Trait Implementations

impl Clone for PrivateLockFile

fn clone(&self) -> PrivateLockFile

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PrivateLockFile

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

Formats the value using the given formatter.

impl Default for PrivateLockFile

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PrivateLockFile

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PrivateLockFile

fn eq(&self, other: &PrivateLockFile) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for PrivateLockFile

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PrivateLockFile