Skip to main content

glass_dev/development/
experiment.rs

1use super::{DevelopmentError, DevelopmentResult};
2use serde::{Deserialize, Serialize};
3use std::{
4    fs,
5    path::{Path, PathBuf},
6    process::Command,
7};
8
9#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10#[serde(rename_all = "camelCase")]
11pub struct ExperimentWorkspace {
12    pub name: String,
13    pub branch: String,
14    pub worktree: PathBuf,
15    pub dev_port: u16,
16    pub browser_url: String,
17    pub agent_thread: String,
18}
19
20#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
21#[serde(rename_all = "camelCase")]
22pub struct ExperimentEvidence {
23    pub name: String,
24    pub files_changed: usize,
25    pub insertions: u64,
26    pub deletions: u64,
27    pub test_status: Option<String>,
28    pub semantic_regressions: Option<usize>,
29    pub workflow_status: Option<String>,
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
33#[serde(rename_all = "camelCase")]
34pub struct ExperimentComparison {
35    pub left: ExperimentEvidence,
36    pub right: ExperimentEvidence,
37}
38
39#[derive(Debug, Clone)]
40pub struct ExperimentManager {
41    repository: PathBuf,
42    root: PathBuf,
43}
44
45impl ExperimentManager {
46    pub fn new(repository: &Path) -> DevelopmentResult<Self> {
47        let repository = fs::canonicalize(repository)?;
48        let output = Command::new("git")
49            .args(["rev-parse", "--show-toplevel"])
50            .current_dir(&repository)
51            .output()?;
52        if !output.status.success() {
53            return Err(DevelopmentError::InvalidInput(
54                "experiments require a Git repository".into(),
55            ));
56        }
57        let top = String::from_utf8(output.stdout)
58            .map_err(|error| DevelopmentError::InvalidInput(error.to_string()))?;
59        let repository = subprocess_compatible_path(fs::canonicalize(top.trim())?);
60        let repository_name = repository
61            .file_name()
62            .and_then(|name| name.to_str())
63            .unwrap_or("project");
64        let root = repository
65            .parent()
66            .unwrap_or(&repository)
67            .join(".glass-worktrees")
68            .join(repository_name);
69        Ok(Self { repository, root })
70    }
71
72    pub fn create(&self, name: &str, dev_port: u16) -> DevelopmentResult<ExperimentWorkspace> {
73        validate_name(name)?;
74        if dev_port == 0 {
75            return Err(DevelopmentError::InvalidInput(
76                "experiment dev port must be non-zero".into(),
77            ));
78        }
79        fs::create_dir_all(&self.root)?;
80        let worktree = self.root.join(name);
81        if worktree.exists() {
82            return Err(DevelopmentError::Conflict(format!(
83                "experiment already exists: {name}"
84            )));
85        }
86        let branch = format!("glass/experiment/{name}");
87        let status = Command::new("git")
88            .args(["worktree", "add", "-b", &branch])
89            .arg(&worktree)
90            .arg("HEAD")
91            .current_dir(&self.repository)
92            .status()?;
93        if !status.success() {
94            return Err(DevelopmentError::Process(format!(
95                "git could not create experiment {name}"
96            )));
97        }
98        Ok(ExperimentWorkspace {
99            name: name.into(),
100            branch,
101            worktree,
102            dev_port,
103            browser_url: format!("http://localhost:{dev_port}"),
104            agent_thread: format!("experiment:{name}"),
105        })
106    }
107
108    pub fn evidence(
109        &self,
110        experiment: &ExperimentWorkspace,
111        test_status: Option<String>,
112        semantic_regressions: Option<usize>,
113        workflow_status: Option<String>,
114    ) -> DevelopmentResult<ExperimentEvidence> {
115        let output = Command::new("git")
116            .args(["diff", "--numstat", "HEAD"])
117            .current_dir(&experiment.worktree)
118            .output()?;
119        if !output.status.success() {
120            return Err(DevelopmentError::Process(format!(
121                "git diff failed for experiment {}",
122                experiment.name
123            )));
124        }
125        let mut files_changed = 0;
126        let mut insertions = 0_u64;
127        let mut deletions = 0_u64;
128        for line in String::from_utf8_lossy(&output.stdout).lines().take(4096) {
129            let mut fields = line.split('\t');
130            let added = fields.next().unwrap_or("0");
131            let removed = fields.next().unwrap_or("0");
132            if fields.next().is_none() {
133                continue;
134            }
135            files_changed += 1;
136            insertions = insertions.saturating_add(added.parse().unwrap_or(0));
137            deletions = deletions.saturating_add(removed.parse().unwrap_or(0));
138        }
139        Ok(ExperimentEvidence {
140            name: experiment.name.clone(),
141            files_changed,
142            insertions,
143            deletions,
144            test_status,
145            semantic_regressions,
146            workflow_status,
147        })
148    }
149
150    pub fn compare(
151        &self,
152        left: ExperimentEvidence,
153        right: ExperimentEvidence,
154    ) -> ExperimentComparison {
155        ExperimentComparison { left, right }
156    }
157}
158
159#[cfg(windows)]
160fn subprocess_compatible_path(path: PathBuf) -> PathBuf {
161    let value = path.to_string_lossy();
162    value
163        .strip_prefix(r"\\?\")
164        .map(PathBuf::from)
165        .unwrap_or(path)
166}
167
168#[cfg(not(windows))]
169fn subprocess_compatible_path(path: PathBuf) -> PathBuf {
170    path
171}
172
173fn validate_name(name: &str) -> DevelopmentResult<()> {
174    if name.is_empty()
175        || name.len() > 48
176        || name
177            .chars()
178            .any(|character| !(character.is_ascii_alphanumeric() || "-_".contains(character)))
179    {
180        return Err(DevelopmentError::InvalidInput(
181            "experiment name must be 1-48 ASCII letters, digits, '-' or '_'".into(),
182        ));
183    }
184    Ok(())
185}
186
187#[cfg(test)]
188mod tests {
189    use super::*;
190
191    #[test]
192    fn worktree_experiment_is_real_and_evidence_is_measured() {
193        let root = std::env::temp_dir().join(format!("glass-experiment-{}", std::process::id()));
194        let _ = fs::remove_dir_all(&root);
195        fs::create_dir_all(&root).unwrap();
196        for args in [
197            vec!["init"],
198            vec!["config", "user.email", "glass@example.invalid"],
199            vec!["config", "user.name", "Glass Test"],
200        ] {
201            assert!(
202                Command::new("git")
203                    .args(args)
204                    .current_dir(&root)
205                    .status()
206                    .unwrap()
207                    .success()
208            );
209        }
210        fs::write(root.join("app.txt"), "base\n").unwrap();
211        assert!(
212            Command::new("git")
213                .args(["add", "."])
214                .current_dir(&root)
215                .status()
216                .unwrap()
217                .success()
218        );
219        assert!(
220            Command::new("git")
221                .args(["commit", "-m", "base"])
222                .current_dir(&root)
223                .status()
224                .unwrap()
225                .success()
226        );
227        let manager = ExperimentManager::new(&root).unwrap();
228        let experiment = manager.create("candidate_a", 3101).unwrap();
229        fs::write(experiment.worktree.join("app.txt"), "base\nchange\n").unwrap();
230        let evidence = manager
231            .evidence(&experiment, Some("pass".into()), Some(0), None)
232            .unwrap();
233        assert_eq!(evidence.files_changed, 1);
234        assert_eq!(evidence.insertions, 1);
235        assert_eq!(experiment.browser_url, "http://localhost:3101");
236        let _ = Command::new("git")
237            .args(["worktree", "remove", "--force"])
238            .arg(&experiment.worktree)
239            .current_dir(&root)
240            .status();
241        let _ = fs::remove_dir_all(root);
242    }
243}