stakpak 0.3.58

Stakpak: Your DevOps AI Agent. Generate infrastructure code, debug Kubernetes, configure CI/CD, automate deployments, without giving an LLM the keys to production.
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
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254

use std::fs;
use std::path::{Path, PathBuf};

/// Maximum number of parent directories to traverse when searching for APPS.md
const MAX_TRAVERSAL_DEPTH: usize = 5;

/// Information about a discovered APPS.md file
#[derive(Debug, Clone)]
pub struct AppsMdInfo {
    pub content: String,
    pub path: PathBuf,
}

/// Discovers and reads the nearest APPS.md file from the given directory upward
/// (up to 3 parent levels), falling back to the global `~/.stakpak/APPS.md`.
///
/// Returns the first (nearest) APPS.md found. Closest to start_dir wins.
///
/// Search order at each directory level:
/// 1. APPS.md (canonical)
/// 2. apps.md (lowercase variant)
///
/// If nothing found within 3 levels:
/// 3. ~/.stakpak/APPS.md (global fallback)
pub fn discover_apps_md(start_dir: &Path) -> Option<AppsMdInfo> {
    let mut current = start_dir.to_path_buf();

    for _ in 0..=MAX_TRAVERSAL_DEPTH {
        // Check canonical APPS.md first
        let apps_file = current.join("APPS.md");
        if apps_file.exists()
            && let Ok(content) = fs::read_to_string(&apps_file)
        {
            return Some(AppsMdInfo {
                content,
                path: apps_file.canonicalize().unwrap_or(apps_file),
            });
        }

        // Check lowercase variant
        let apps_file_lower = current.join("apps.md");
        if apps_file_lower.exists()
            && let Ok(content) = fs::read_to_string(&apps_file_lower)
        {
            return Some(AppsMdInfo {
                content,
                path: apps_file_lower.canonicalize().unwrap_or(apps_file_lower),
            });
        }

        // Move up to parent directory
        if !current.pop() {
            break;
        }
    }

    // Fall back to global ~/.stakpak/APPS.md
    if let Some(home) = std::env::home_dir() {
        let global_apps = home.join(".stakpak").join("APPS.md");
        if global_apps.exists()
            && let Ok(content) = fs::read_to_string(&global_apps)
        {
            return Some(AppsMdInfo {
                content,
                path: global_apps.canonicalize().unwrap_or(global_apps),
            });
        }
    }

    None
}

/// Format APPS.md content for context injection
pub fn format_apps_md_for_context(info: &AppsMdInfo) -> String {
    format!(
        "# APPS.md (from {})\n\n{}",
        info.path.display(),
        info.content.trim()
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs::File;
    use std::io::Write;
    use tempfile::TempDir;

    #[test]
    fn test_discover_apps_md_in_current_dir() {
        let temp_dir = TempDir::new().unwrap();
        let apps_path = temp_dir.path().join("APPS.md");
        let mut file = File::create(&apps_path).unwrap();
        writeln!(file, "# Test APPS.md\n\nSome content").unwrap();

        let result = discover_apps_md(temp_dir.path());
        assert!(result.is_some());
        let info = result.unwrap();
        assert!(info.content.contains("Test APPS.md"));
        assert_eq!(info.path, apps_path.canonicalize().unwrap());
    }

    #[test]
    fn test_discover_apps_md_in_parent_dir() {
        let temp_dir = TempDir::new().unwrap();
        let apps_path = temp_dir.path().join("APPS.md");
        let mut file = File::create(&apps_path).unwrap();
        writeln!(file, "# Parent APPS.md").unwrap();

        let child_dir = temp_dir.path().join("subdir");
        fs::create_dir(&child_dir).unwrap();

        let result = discover_apps_md(&child_dir);
        assert!(result.is_some());
        let info = result.unwrap();
        assert!(info.content.contains("Parent APPS.md"));
    }

    #[test]
    fn test_discover_apps_md_lowercase() {
        let temp_dir = TempDir::new().unwrap();
        let apps_path = temp_dir.path().join("apps.md");
        let mut file = File::create(&apps_path).unwrap();
        writeln!(file, "# Lowercase apps.md").unwrap();

        let result = discover_apps_md(temp_dir.path());
        assert!(result.is_some());
        let info = result.unwrap();
        assert!(info.content.contains("Lowercase apps.md"));
    }

    #[test]
    fn test_discover_apps_md_respects_max_depth() {
        let temp_dir = TempDir::new().unwrap();

        // Create APPS.md 7 levels up — should NOT be found (max depth is 5)
        let apps_path = temp_dir.path().join("APPS.md");
        let mut file = File::create(&apps_path).unwrap();
        writeln!(file, "# Too far APPS.md").unwrap();

        let deep_dir = temp_dir
            .path()
            .join("a")
            .join("b")
            .join("c")
            .join("d")
            .join("e")
            .join("f")
            .join("g");
        fs::create_dir_all(&deep_dir).unwrap();

        let result = discover_apps_md(&deep_dir);
        // Should not find the APPS.md that is 7 levels up
        if let Some(info) = result {
            assert!(
                !info.content.contains("Too far"),
                "Should not discover APPS.md beyond max traversal depth"
            );
        }
    }

    #[test]
    fn test_discover_apps_md_within_max_depth() {
        let temp_dir = TempDir::new().unwrap();

        // Create APPS.md 5 levels up — should be found
        let apps_path = temp_dir.path().join("APPS.md");
        let mut file = File::create(&apps_path).unwrap();
        writeln!(file, "# Reachable APPS.md").unwrap();

        let deep_dir = temp_dir
            .path()
            .join("a")
            .join("b")
            .join("c")
            .join("d")
            .join("e");
        fs::create_dir_all(&deep_dir).unwrap();

        let result = discover_apps_md(&deep_dir);
        assert!(result.is_some());
        assert!(
            result.unwrap().content.contains("Reachable"),
            "Should discover APPS.md within max traversal depth"
        );
    }

    #[test]
    fn test_discover_apps_md_nearest_wins() {
        let temp_dir = TempDir::new().unwrap();

        // Create APPS.md at root
        let root_apps = temp_dir.path().join("APPS.md");
        let mut file = File::create(&root_apps).unwrap();
        writeln!(file, "# Root APPS.md").unwrap();

        // Create APPS.md in child
        let child_dir = temp_dir.path().join("child");
        fs::create_dir(&child_dir).unwrap();
        let child_apps = child_dir.join("APPS.md");
        let mut file = File::create(&child_apps).unwrap();
        writeln!(file, "# Child APPS.md").unwrap();

        let result = discover_apps_md(&child_dir);
        assert!(result.is_some());
        let info = result.unwrap();
        // Nearest (child) should win
        assert!(info.content.contains("Child APPS.md"));
        assert_eq!(info.path, child_apps.canonicalize().unwrap());
    }

    #[test]
    fn test_discover_apps_md_not_found() {
        let temp_dir = TempDir::new().unwrap();
        let result = discover_apps_md(temp_dir.path());
        // May find global ~/.stakpak/APPS.md if it exists, otherwise None
        if let Some(info) = result {
            assert!(
                info.path.to_string_lossy().contains(".stakpak"),
                "Should only find global APPS.md (if any)"
            );
        }
    }

    #[test]
    fn test_discover_apps_md_canonical_takes_precedence() {
        let temp_dir = TempDir::new().unwrap();

        // Create canonical APPS.md
        let canonical = temp_dir.path().join("APPS.md");
        let mut file = File::create(&canonical).unwrap();
        writeln!(file, "# Canonical").unwrap();

        // On case-insensitive filesystems (macOS, Windows), creating apps.md
        // would overwrite APPS.md. So we just verify that APPS.md is found
        // when it exists (the precedence logic works on case-sensitive systems).
        let result = discover_apps_md(temp_dir.path());
        assert!(result.is_some());
        assert!(result.unwrap().content.contains("Canonical"));
    }

    #[test]
    fn test_format_apps_md_for_context() {
        let info = AppsMdInfo {
            content: "## My App\n- Port 8080".to_string(),
            path: PathBuf::from("/project/APPS.md"),
        };

        let formatted = format_apps_md_for_context(&info);
        assert!(formatted.contains("# APPS.md (from /project/APPS.md)"));
        assert!(formatted.contains("## My App"));
        assert!(formatted.contains("- Port 8080"));
    }
}