agpm-cli 0.4.14

AGent Package Manager - A Git-based package manager for coding agents
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229

use anyhow::Result;

use crate::common::{ManifestBuilder, TestProject};

/// Test that incremental update only re-resolves specified dependencies
#[tokio::test]
async fn test_incremental_resolves_only_specified_deps() -> Result<()> {
    agpm_cli::test_utils::init_test_logging(None);

    let project = TestProject::new().await?;

    // Create remote repository with agent1 at v1.0.0
    let remote = project.create_source_repo("remote").await?;
    remote.add_resource("agents", "agent1", "---\nname: agent1\n---\nOriginal agent1").await?;
    remote.commit_all("Initial agent1")?;
    remote.tag_version("v1.0.0")?;

    // Add agent2 at v1.1.0
    remote.add_resource("agents", "agent2", "---\nname: agent2\n---\nOriginal agent2").await?;
    remote.commit_all("Add agent2")?;
    remote.tag_version("v1.1.0")?;

    // Create manifest with both agents
    let remote_url = remote.bare_file_url(project.sources_path()).await?;
    let manifest = ManifestBuilder::new()
        .add_source("remote", &remote_url)
        .add_agent("agent1", |d| d.source("remote").path("agents/agent1.md").version("v1.0.0"))
        .add_agent("agent2", |d| d.source("remote").path("agents/agent2.md").version("v1.1.0"))
        .build();

    project.write_manifest(&manifest).await?;

    // Initial install
    let output = project.run_agpm(&["install"])?;
    assert!(output.success, "Install should succeed. Stderr: {}", output.stderr);

    // Verify both agents installed
    let agent1_path = project.project_path().join(".claude/agents/agpm/agent1.md");
    let agent2_path = project.project_path().join(".claude/agents/agpm/agent2.md");
    assert!(tokio::fs::metadata(&agent1_path).await.is_ok(), "Agent1 should exist");
    assert!(tokio::fs::metadata(&agent2_path).await.is_ok(), "Agent2 should exist");

    // Update agent1 in remote to v1.0.1
    remote.add_resource("agents", "agent1", "---\nname: agent1\n---\nUpdated agent1").await?;
    remote.commit_all("Update agent1")?;
    remote.tag_version("v1.0.1")?;

    // Update agent2 in remote to v1.1.1
    remote.add_resource("agents", "agent2", "---\nname: agent2\n---\nUpdated agent2").await?;
    remote.commit_all("Update agent2")?;
    remote.tag_version("v1.1.1")?;

    // Update the bare repository to include new tags
    // This is necessary because the bare repo was created before we added the new tags
    let bare_path = project.sources_path().join("remote.git");
    std::fs::remove_dir_all(&bare_path)?;
    remote.to_bare_repo(&bare_path).await?;

    // Update manifest to allow patch updates
    // Use tilde (~) constraints to allow only patch-level updates (1.0.x, 1.1.x)
    let manifest = ManifestBuilder::new()
        .add_source("remote", &remote_url)
        .add_agent("agent1", |d| d.source("remote").path("agents/agent1.md").version("~v1.0.0"))
        .add_agent("agent2", |d| d.source("remote").path("agents/agent2.md").version("~v1.1.0"))
        .build();

    project.write_manifest(&manifest).await?;

    // Update only agent1
    let output = project.run_agpm(&["update", "agent1"])?;
    assert!(output.success, "Update should succeed. Stderr: {}", output.stderr);

    // Read lockfile to verify versions
    let lockfile = project.load_lockfile()?;

    // agent1 should be at v1.0.1
    let agent1 =
        lockfile.agents.iter().find(|a| a.name == "agents/agent1").expect("agent1 not found");
    assert_eq!(agent1.version, Some("v1.0.1".to_string()));

    // agent2 should still be at v1.1.0 (unchanged)
    let agent2 =
        lockfile.agents.iter().find(|a| a.name == "agents/agent2").expect("agent2 not found");
    assert_eq!(agent2.version, Some("v1.1.0".to_string()));

    Ok(())
}

/// Test that incremental update with multiple dependencies works correctly
#[tokio::test]
async fn test_incremental_multiple_dependencies() -> Result<()> {
    agpm_cli::test_utils::init_test_logging(None);

    let project = TestProject::new().await?;

    // Create remote repository with initial resources at v1.0.0
    let remote = project.create_source_repo("remote").await?;
    remote.add_resource("agents", "agent1", "---\nname: agent1\n---\nOriginal agent1").await?;
    remote.add_resource("agents", "agent2", "---\nname: agent2\n---\nOriginal agent2").await?;
    remote.add_resource("snippets", "snippet1", "# Snippet 1\nOriginal snippet1").await?;
    remote.commit_all("Initial resources")?;
    remote.tag_version("v1.0.0")?;

    // Create manifest
    let remote_url = remote.bare_file_url(project.sources_path()).await?;
    let manifest = ManifestBuilder::new()
        .add_source("remote", &remote_url)
        .add_standard_agent("agent1", "remote", "agents/agent1.md")
        .add_standard_agent("agent2", "remote", "agents/agent2.md")
        .add_standard_snippet("snippet1", "remote", "snippets/snippet1.md")
        .build();

    project.write_manifest(&manifest).await?;

    // Initial install
    let output = project.run_agpm(&["install"])?;
    assert!(output.success, "Install should succeed. Stderr: {}", output.stderr);

    // Update all resources to v1.1.0
    remote.add_resource("agents", "agent1", "---\nname: agent1\n---\nUpdated agent1").await?;
    remote.add_resource("agents", "agent2", "---\nname: agent2\n---\nUpdated agent2").await?;
    remote.add_resource("snippets", "snippet1", "# Snippet 1\nUpdated snippet1").await?;
    remote.commit_all("Update all")?;
    remote.tag_version("v1.1.0")?;

    // Update the bare repository to include new tags
    let bare_path = project.sources_path().join("remote.git");
    std::fs::remove_dir_all(&bare_path)?;
    remote.to_bare_repo(&bare_path).await?;

    // Update manifest to allow minor version updates
    // Use caret (^) to allow minor updates (1.0.0 -> 1.1.0)
    // For incremental update test, only agent1 and snippet1 should update
    let manifest = ManifestBuilder::new()
        .add_source("remote", &remote_url)
        .add_agent("agent1", |d| d.source("remote").path("agents/agent1.md").version("^v1.0.0"))
        .add_agent("agent2", |d| d.source("remote").path("agents/agent2.md").version("^v1.0.0"))
        .add_snippet("snippet1", |d| {
            d.source("remote").path("snippets/snippet1.md").version("^v1.0.0")
        })
        .build();

    project.write_manifest(&manifest).await?;

    // Update agent1 and snippet1, but not agent2
    let output = project.run_agpm(&["update", "agent1", "snippet1"])?;
    assert!(
        output.success,
        "Update should succeed. Stderr: {}\nStdout: {}",
        output.stderr, output.stdout
    );

    // Read lockfile to verify versions
    let lockfile_content = project.read_lockfile().await?;
    let lockfile = project.load_lockfile()?;

    // agent1 should be updated
    let agent1 =
        lockfile.agents.iter().find(|a| a.name == "agents/agent1").expect("agent1 not found");
    assert_eq!(
        agent1.version,
        Some("v1.1.0".to_string()),
        "agent1 should be v1.1.0, got {:?}. Lockfile:\n{}",
        agent1.version,
        lockfile_content
    );

    // agent2 should be unchanged
    let agent2 =
        lockfile.agents.iter().find(|a| a.name == "agents/agent2").expect("agent2 not found");
    assert_eq!(agent2.version, Some("v1.0.0".to_string()));

    // snippet1 should be updated
    let snippet1 = lockfile
        .snippets
        .iter()
        .find(|s| s.name == "snippets/snippet1")
        .expect("snippet1 not found");
    assert_eq!(snippet1.version, Some("v1.1.0".to_string()));

    Ok(())
}

/// Test that incremental update with non-existent dependency is handled gracefully
///
/// Current behavior: Does full resolution and returns existing lockfile unchanged.
/// Future enhancement: Could show user-friendly warning about non-existent dependency.
#[tokio::test]
async fn test_incremental_nonexistent_dependency() -> Result<()> {
    agpm_cli::test_utils::init_test_logging(None);

    let project = TestProject::new().await?;

    // Create remote repository with agent1 at v1.0.0
    let remote = project.create_source_repo("remote").await?;
    remote.add_resource("agents", "agent1", "---\nname: agent1\n---\nAgent content").await?;
    remote.commit_all("Initial commit")?;
    remote.tag_version("v1.0.0")?;

    // Create manifest
    let remote_url = remote.bare_file_url(project.sources_path()).await?;
    let manifest = ManifestBuilder::new()
        .add_source("remote", &remote_url)
        .add_standard_agent("agent1", "remote", "agents/agent1.md")
        .build();

    project.write_manifest(&manifest).await?;

    // Initial install
    let output = project.run_agpm(&["install"])?;
    assert!(output.success, "Install should succeed. Stderr: {}", output.stderr);

    // Get initial lockfile
    let initial_lockfile = project.read_lockfile().await?;

    // Try to update a non-existent dependency
    // Current behavior: Should succeed and return unchanged lockfile
    let output = project.run_agpm(&["update", "nonexistent"])?;
    assert!(output.success, "Update should succeed. Stderr: {}", output.stderr);

    // Lockfile should be unchanged
    let final_lockfile = project.read_lockfile().await?;
    assert_eq!(
        initial_lockfile, final_lockfile,
        "Lockfile should be unchanged when updating non-existent dependency"
    );

    Ok(())
}