agpm-cli 0.4.4

AGent Package Manager - A Git-based package manager for Claude 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

//! Integration tests for --max-parallel flag behavior
//! Tests the new v0.3.0 concurrency control features

use assert_cmd::prelude::*;
use predicates::prelude::*;
use std::process::Command;
use tokio::fs;

mod common;
mod fixtures;
use common::TestProject;

/// Test --max-parallel flag with various values
#[tokio::test]
async fn test_max_parallel_flag_values() {
    let project = TestProject::new().await.unwrap();

    // Create a simple test source
    let official_repo = project.create_source_repo("official").await.unwrap();
    official_repo
        .add_resource("agents", "test-agent-1", "# Test Agent 1\n\nA test agent")
        .await
        .unwrap();
    official_repo
        .add_resource("agents", "test-agent-2", "# Test Agent 2\n\nA test agent")
        .await
        .unwrap();
    official_repo
        .add_resource("agents", "test-agent-3", "# Test Agent 3\n\nA test agent")
        .await
        .unwrap();
    official_repo.commit_all("Initial commit").unwrap();
    official_repo.tag_version("v1.0.0").unwrap();

    let source_url = official_repo.bare_file_url(project.sources_path()).unwrap();
    let manifest_content = format!(
        r#"
[sources]
official = "{}"

[agents]
agent1 = {{ source = "official", path = "agents/test-agent-1.md", version = "v1.0.0" }}
agent2 = {{ source = "official", path = "agents/test-agent-2.md", version = "v1.0.0" }}
agent3 = {{ source = "official", path = "agents/test-agent-3.md", version = "v1.0.0" }}
"#,
        source_url
    );

    project.write_manifest(&manifest_content).await.unwrap();

    // Test different --max-parallel values
    for max_parallel in [1, 2, 4, 8] {
        let output =
            project.run_agpm(&["install", "--max-parallel", &max_parallel.to_string()]).unwrap();
        assert!(
            output.success,
            "Install failed with max_parallel={}: {}",
            max_parallel, output.stderr
        );

        // Verify installation worked
        // Files use basename from path, not dependency name
        assert!(project.project_path().join(".claude/agents/test-agent-1.md").exists());
        assert!(project.project_path().join(".claude/agents/test-agent-2.md").exists());
        assert!(project.project_path().join(".claude/agents/test-agent-3.md").exists());

        // Clean up for next iteration
        let _ = fs::remove_dir_all(project.project_path().join(".claude")).await;
    }
}

/// Test --max-parallel with invalid values
#[tokio::test]
async fn test_max_parallel_invalid_values() {
    let project = TestProject::new().await.unwrap();

    // Test zero value
    let output = project.run_agpm(&["install", "--max-parallel", "0"]).unwrap();
    assert!(!output.success);

    // Test negative value
    let output = project.run_agpm(&["install", "--max-parallel", "-1"]).unwrap();
    assert!(!output.success);

    // Test non-numeric value
    let output = project.run_agpm(&["install", "--max-parallel", "abc"]).unwrap();
    assert!(!output.success);
}

/// Test default parallelism when --max-parallel is not specified
#[tokio::test]
async fn test_default_parallelism() {
    let project = TestProject::new().await.unwrap();

    let official_repo = project.create_source_repo("official").await.unwrap();
    official_repo
        .add_resource("agents", "test-agent", "# Test Agent\n\nA test agent")
        .await
        .unwrap();
    official_repo.commit_all("Initial commit").unwrap();
    official_repo.tag_version("v1.0.0").unwrap();

    let source_url = official_repo.bare_file_url(project.sources_path()).unwrap();
    let manifest_content = format!(
        r#"
[sources]
official = "{}"

[agents]
agent = {{ source = "official", path = "agents/test-agent.md", version = "v1.0.0" }}
"#,
        source_url
    );

    project.write_manifest(&manifest_content).await.unwrap();

    // Install without --max-parallel flag (should use default)
    let output = project.run_agpm(&["install"]).unwrap();
    assert!(output.success);
    assert!(output.stdout.contains("Installing") || output.stdout.contains("Installed"));

    // Files use basename from path, not dependency name
    assert!(project.project_path().join(".claude/agents/test-agent.md").exists());
}

/// Test --max-parallel flag on install command only (update doesn't support it)
#[tokio::test]
async fn test_max_parallel_install_only() {
    let project = TestProject::new().await.unwrap();

    let official_repo = project.create_source_repo("official").await.unwrap();
    official_repo
        .add_resource("agents", "test-agent", "# Test Agent\n\nA test agent")
        .await
        .unwrap();
    official_repo.commit_all("Initial commit").unwrap();
    official_repo.tag_version("v1.0.0").unwrap();

    let source_url = official_repo.bare_file_url(project.sources_path()).unwrap();
    let manifest_content = format!(
        r#"
[sources]
official = "{}"

[agents]
agent = {{ source = "official", path = "agents/test-agent.md", version = "v1.0.0" }}
"#,
        source_url
    );

    project.write_manifest(&manifest_content).await.unwrap();

    // Install with --max-parallel should work
    let output = project.run_agpm(&["install", "--max-parallel", "2"]).unwrap();
    assert!(output.success);

    // Update command should work without --max-parallel
    let output = project.run_agpm(&["update"]).unwrap();
    assert!(output.success);
}

/// Test --max-parallel in help output for install command
#[tokio::test]
async fn test_max_parallel_help_coverage() {
    let mut cmd = Command::cargo_bin("agpm").unwrap();
    cmd.arg("install")
        .arg("--help")
        .assert()
        .success()
        .stdout(predicate::str::contains("--max-parallel"));
}