appshots-mcp 0.3.0

MCP server for generating ASO-optimized App Store screenshots
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

use std::path::PathBuf;

use crate::error::AppShotsError;
use crate::model::template::{ResolutionSource, TemplatePath};

/// Resolve template file for a given mode.
///
/// Uses a closure for existence check to stay pure (no I/O).
/// Resolution chain:
/// 1. `{base}/templates/template-{mode}.typ`
/// 2. `{base}/templates/template.typ`
/// 3. `{base}/template.typ`
pub fn resolve_template(
    base_dir: &str,
    mode: u8,
    exists_fn: impl Fn(&str) -> bool,
) -> Result<TemplatePath, AppShotsError> {
    // 1. Mode-specific template
    let mode_specific = format!("{base_dir}/templates/template-{mode}.typ");
    if exists_fn(&mode_specific) {
        return Ok(TemplatePath {
            resolved: PathBuf::from(mode_specific),
            source: ResolutionSource::ModeSpecific { mode },
        });
    }

    // 2. Shared template in templates/
    let shared = format!("{base_dir}/templates/template.typ");
    if exists_fn(&shared) {
        return Ok(TemplatePath {
            resolved: PathBuf::from(shared),
            source: ResolutionSource::SharedFallback,
        });
    }

    // 3. Root template
    let root = format!("{base_dir}/template.typ");
    if exists_fn(&root) {
        return Ok(TemplatePath {
            resolved: PathBuf::from(root),
            source: ResolutionSource::RootFallback,
        });
    }

    Err(AppShotsError::TemplateNotFound {
        path: PathBuf::from(format!(
            "{base_dir}/templates/template-{mode}.typ (and fallbacks)"
        )),
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn resolve_mode_specific() {
        let result = resolve_template("/app/appshots", 3, |path| {
            path == "/app/appshots/templates/template-3.typ"
        })
        .unwrap();
        assert_eq!(
            result.resolved,
            PathBuf::from("/app/appshots/templates/template-3.typ")
        );
        assert_eq!(result.source, ResolutionSource::ModeSpecific { mode: 3 });
    }

    #[test]
    fn resolve_shared_fallback() {
        let result = resolve_template("/app/appshots", 3, |path| {
            path == "/app/appshots/templates/template.typ"
        })
        .unwrap();
        assert_eq!(
            result.resolved,
            PathBuf::from("/app/appshots/templates/template.typ")
        );
        assert_eq!(result.source, ResolutionSource::SharedFallback);
    }

    #[test]
    fn resolve_root_fallback() {
        let result = resolve_template("/app/appshots", 1, |path| {
            path == "/app/appshots/template.typ"
        })
        .unwrap();
        assert_eq!(result.resolved, PathBuf::from("/app/appshots/template.typ"));
        assert_eq!(result.source, ResolutionSource::RootFallback);
    }

    #[test]
    fn resolve_prefers_mode_specific_over_shared() {
        let result = resolve_template("/app/appshots", 2, |path| {
            path == "/app/appshots/templates/template-2.typ"
                || path == "/app/appshots/templates/template.typ"
                || path == "/app/appshots/template.typ"
        })
        .unwrap();
        assert_eq!(result.source, ResolutionSource::ModeSpecific { mode: 2 });
    }

    #[test]
    fn resolve_prefers_shared_over_root() {
        let result = resolve_template("/app/appshots", 5, |path| {
            path == "/app/appshots/templates/template.typ" || path == "/app/appshots/template.typ"
        })
        .unwrap();
        assert_eq!(result.source, ResolutionSource::SharedFallback);
    }

    #[test]
    fn resolve_none_found() {
        let result = resolve_template("/app/appshots", 1, |_| false);
        assert!(result.is_err());
        let err = result.unwrap_err();
        assert!(matches!(err, AppShotsError::TemplateNotFound { .. }));
    }
}