selfware 0.6.1

Your personal AI workshop — software you own, software that lasts
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

//! L5: Visual Mockup to TUI Layout (Extreme)
//!
//! Input: Hand-drawn or ASCII mockup of a TUI layout.
//! Tasks: Generate ratatui Rust code, identify widget types, specify constraints.
//! Scoring: Widget type identification, layout constraint accuracy, code compilability.
//! Pass threshold: 40% structural accuracy.

use async_trait::async_trait;
use std::path::PathBuf;

use crate::vlm_bench::scoring::{self, LevelScore, Rating};
use crate::vlm_bench::{BenchScenario, Difficulty, ExpectedAnswer, VlmBenchLevel};

const PASS_THRESHOLD: f64 = 0.40;

/// Level 5: Visual Mockup to TUI Layout.
pub struct L5Layout {
    fixtures_dir: PathBuf,
}

impl Default for L5Layout {
    fn default() -> Self {
        Self::new()
    }
}

impl L5Layout {
    pub fn new() -> Self {
        Self {
            fixtures_dir: PathBuf::from("vlm_fixtures/l5_layout"),
        }
    }
}

#[async_trait]
impl VlmBenchLevel for L5Layout {
    fn name(&self) -> &str {
        "L5 Layout"
    }

    fn difficulty(&self) -> Difficulty {
        Difficulty::Extreme
    }

    fn description(&self) -> &str {
        "Visual mockup to code translation: identify widget types from ASCII/visual mockups, \
         generate ratatui layout code, specify correct constraint percentages."
    }

    fn scenarios(&self) -> Vec<BenchScenario> {
        vec![
            BenchScenario {
                id: "l5_simple_split".into(),
                description: "Translate a simple horizontal split layout to ratatui code".into(),
                image_path: self.fixtures_dir.join("simple_split.png"),
                prompt: "This mockup shows a terminal UI with a horizontal split layout. \
                         Identify the widget types and generate the ratatui layout code. \
                         Respond with JSON: {\"widgets\": [{\"type\": \"<widget type>\", \
                         \"position\": \"<left|right|top|bottom>\", \
                         \"constraint\": \"<Percentage(N) or Min(N)>\"}], \
                         \"layout_direction\": \"<Horizontal|Vertical>\", \
                         \"code_snippet\": \"<ratatui layout code>\"}"
                    .into(),
                expected: ExpectedAnswer::Keywords(vec![
                    "layout".into(),
                    "horizontal".into(),
                    "constraint".into(),
                    "percentage".into(),
                ]),
            },
            BenchScenario {
                id: "l5_dashboard_grid".into(),
                description: "Translate a grid-based dashboard mockup to code".into(),
                image_path: self.fixtures_dir.join("dashboard_grid.png"),
                prompt: "This mockup shows a dashboard with a grid layout: \
                         header bar at top, sidebar on left, main content area, \
                         and status bar at bottom. Describe the layout hierarchy \
                         and widget types. Respond with JSON: \
                         {\"layout_tree\": {\"direction\": \"Vertical\", \
                         \"children\": [...]}, \
                         \"widget_types\": [\"<type>\", ...]}"
                    .into(),
                expected: ExpectedAnswer::Keywords(vec![
                    "vertical".into(),
                    "horizontal".into(),
                    "header".into(),
                    "sidebar".into(),
                ]),
            },
            BenchScenario {
                id: "l5_complex_nested".into(),
                description: "Translate a complex nested layout with multiple widget types".into(),
                image_path: self.fixtures_dir.join("complex_nested.png"),
                prompt: "This mockup shows a complex TUI with nested layouts: \
                         tab bar, split panes with different widget types (list, chart, text), \
                         and a floating popup. Describe the full layout structure and \
                         identify all widget types. Respond with JSON: \
                         {\"widgets\": [{\"type\": \"<type>\", \"name\": \"<name>\"}], \
                         \"nesting_depth\": <N>, \"has_popup\": true/false, \
                         \"code_outline\": \"<pseudocode or ratatui code>\"}"
                    .into(),
                expected: ExpectedAnswer::Keywords(vec![
                    "tab".into(),
                    "list".into(),
                    "chart".into(),
                    "popup".into(),
                    "nested".into(),
                ]),
            },
        ]
    }

    fn evaluate(&self, scenario: &BenchScenario, response: &str) -> LevelScore {
        crate::vlm_bench::score_response(scenario, response, PASS_THRESHOLD)
    }
}

#[cfg(test)]
#[path = "../../../tests/unit/vlm_bench/levels/l5_layout/l5_layout_test.rs"]
mod tests;