augent 0.6.6

Lean package manager for various AI coding platforms
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

//! Tests for installing directory bundles by path

mod common;

use predicates::prelude::PredicateBooleanExt;

#[test]
fn test_install_dir_bundle_with_path() {
    let workspace = common::TestWorkspace::new();
    workspace.init_from_fixture("empty");
    workspace.create_agent_dir("cursor");

    // Create a local bundle directory
    workspace.create_bundle("my-local-bundle");
    workspace.write_file(
        "bundles/my-local-bundle/commands/hello.md",
        "# Hello Command\n",
    );

    // Install the bundle using its path
    common::augent_cmd_for_workspace(&workspace.path)
        .args([
            "install",
            "./bundles/my-local-bundle",
            "--to",
            "cursor",
            "-y",
        ])
        .assert()
        .success();

    // Verify the bundle was added to augent.yaml
    let augent_yaml = std::fs::read_to_string(workspace.path.join(".augent/augent.yaml"))
        .expect("Failed to read augent.yaml");
    assert!(augent_yaml.contains("name: my-local-bundle"));
    assert!(augent_yaml.contains("path: ./bundles/my-local-bundle"));

    // Verify the file was installed
    assert!(workspace.path.join(".cursor/commands/hello.md").exists());
}

#[test]
fn test_install_current_directory_as_bundle() {
    let workspace = common::TestWorkspace::new();
    workspace.init_from_fixture("empty");
    workspace.create_agent_dir("cursor");

    // Create a bundle directory
    let bundle_dir = workspace.path.join("my-bundle");
    std::fs::create_dir_all(&bundle_dir).expect("Failed to create bundle directory");
    workspace.write_file("my-bundle/commands/test.md", "# Test Command\n");

    // Write augent.yaml to the bundle directory so it's treated as a bundle
    workspace.write_file("my-bundle/augent.yaml", "name: \"my-bundle\"\n");

    // Navigate to the bundle directory
    std::env::set_current_dir(&bundle_dir).expect("Failed to set current directory");

    // Install using "." to add current directory as a bundle
    common::augent_cmd_for_workspace(&workspace.path)
        .current_dir(&bundle_dir)
        .args(["install", ".", "--to", "cursor", "-y"])
        .assert()
        .success();

    // Verify the bundle was added to augent.yaml
    let augent_yaml = std::fs::read_to_string(workspace.path.join(".augent/augent.yaml"))
        .expect("Failed to read augent.yaml");
    assert!(augent_yaml.contains("name: my-bundle"));
    assert!(augent_yaml.contains("path: ./my-bundle"));

    // Verify the file was installed
    assert!(workspace.path.join(".cursor/commands/test.md").exists());
}

#[test]
fn test_install_path_outside_repository_fails() {
    let workspace = common::TestWorkspace::new();
    workspace.init_from_fixture("empty");

    // Try to install a bundle from a path outside of repository
    // This should fail with an appropriate error message
    common::augent_cmd_for_workspace(&workspace.path)
        .args([
            "install",
            "/some/absolute/path/outside/repo",
            "--to",
            "cursor",
        ])
        .assert()
        .failure()
        .stderr(
            predicates::str::contains("outside repository")
                .or(predicates::str::contains("within repository"))
                .or(predicates::str::contains("workspace")),
        );
}

#[test]
fn test_install_existing_dir_bundle_path() {
    let workspace = common::TestWorkspace::new();
    workspace.init_from_fixture("empty");
    workspace.create_agent_dir("cursor");

    // Create a local bundle directory
    workspace.create_bundle("existing-bundle");
    workspace.write_file(
        "bundles/existing-bundle/commands/existing.md",
        "# Existing Command\n",
    );

    // Write augent.yaml to the bundle directory so it's treated as a bundle
    workspace.write_file(
        "bundles/existing-bundle/augent.yaml",
        "name: \"existing-bundle\"\n",
    );

    // First install
    common::augent_cmd_for_workspace(&workspace.path)
        .args([
            "install",
            "./bundles/existing-bundle",
            "--to",
            "cursor",
            "-y",
        ])
        .assert()
        .success();

    // Verify it was added
    let augent_yaml = std::fs::read_to_string(workspace.path.join(".augent/augent.yaml"))
        .expect("Failed to read augent.yaml");
    assert!(augent_yaml.contains("name: existing-bundle"));

    // Verify files from first install
    assert!(workspace.path.join(".cursor/commands/existing.md").exists());
    assert!(
        !workspace.path.join(".cursor/commands/updated.md").exists(),
        "Updated file should not exist after first install"
    );

    // Update the bundle
    workspace.write_file(
        "bundles/existing-bundle/commands/updated.md",
        "# Updated Command\n",
    );

    // Install again - should update the bundle
    common::augent_cmd_for_workspace(&workspace.path)
        .args([
            "install",
            "./bundles/existing-bundle",
            "--to",
            "cursor",
            "-y",
        ])
        .assert()
        .success();

    // Verify the updated file was installed
    assert!(workspace.path.join(".cursor/commands/updated.md").exists());
}