refactor(vcs): convert VcsDriver trait to native async

Replace manual tokio::runtime::Handle::current().block_on() calls with
native async/await throughout all VCS drivers. Introduce AnyVcsDriver
enum for static dispatch to avoid dyn trait with async methods.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

1 files changed, 34 insertions, 30 deletions

diff --git a/crates/mozart-vcs/src/driver/gitlab.rs b/crates/mozart-vcs/src/driver/gitlab.rs
index ed88f27..7b1a93b 100644
--- a/crates/mozart-vcs/src/driver/gitlab.rs
+++ b/crates/mozart-vcs/src/driver/gitlab.rs
@@ -80,8 +80,7 @@ impl GitLabDriver {
         )
     }
 
-    fn api_get(&self, path: &str) -> Result<serde_json::Value> {
-        let handle = tokio::runtime::Handle::current();
+    async fn api_get(&self, path: &str) -> Result<serde_json::Value> {
         let url = self.api_url(path);
         let mut req = self
             .http_client
@@ -93,7 +92,7 @@ impl GitLabDriver {
             req = req.header("PRIVATE-TOKEN", token.as_str());
         }
 
-        let response = handle.block_on(req.send())?;
+        let response = req.send().await?;
         if !response.status().is_success() {
             bail!(
                 "GitLab API request to {} failed with status {}",
@@ -101,16 +100,16 @@ impl GitLabDriver {
                 response.status()
             );
         }
-        Ok(handle.block_on(response.json())?)
+        Ok(response.json().await?)
     }
 
-    fn api_get_paginated(&self, path: &str) -> Result<Vec<serde_json::Value>> {
+    async fn api_get_paginated(&self, path: &str) -> Result<Vec<serde_json::Value>> {
         let mut items = Vec::new();
         let mut page = 1;
         loop {
             let sep = if path.contains('?') { "&" } else { "?" };
             let paged_path = format!("{path}{sep}per_page=100&page={page}");
-            let data = self.api_get(&paged_path)?;
+            let data = self.api_get(&paged_path).await?;
             let batch: Vec<serde_json::Value> = match data {
                 serde_json::Value::Array(arr) => arr,
                 _ => break,
@@ -127,14 +126,14 @@ impl GitLabDriver {
         Ok(items)
     }
 
-    fn use_git_fallback(&mut self) -> Result<&mut GitDriver> {
+    async fn use_git_fallback(&mut self) -> Result<&mut GitDriver> {
         if self.git_driver.is_none() {
             let git_url = format!(
                 "{}://{}/{}/{}.git",
                 self.scheme, self.host, self.owner, self.repo
             );
             let mut driver = GitDriver::new(&git_url, self.config.clone());
-            driver.initialize()?;
+            driver.initialize().await?;
             self.git_driver = Some(Box::new(driver));
         }
         Ok(self.git_driver.as_mut().unwrap())
@@ -142,8 +141,8 @@ impl GitLabDriver {
 }
 
 impl VcsDriver for GitLabDriver {
-    fn initialize(&mut self) -> Result<()> {
-        match self.api_get("") {
+    async fn initialize(&mut self) -> Result<()> {
+        match self.api_get("").await {
             Ok(data) => {
                 if let Some(id) = data["id"].as_u64() {
                     self.project_id = Some(id.to_string());
@@ -156,7 +155,7 @@ impl VcsDriver for GitLabDriver {
             }
             Err(_) => {
                 self.api_failed = true;
-                let driver = self.use_git_fallback()?;
+                let driver = self.use_git_fallback().await?;
                 self.root_identifier = Some(driver.root_identifier().to_string());
             }
         }
@@ -167,14 +166,14 @@ impl VcsDriver for GitLabDriver {
         self.root_identifier.as_deref().unwrap_or("main")
     }
 
-    fn branches(&mut self) -> Result<&BTreeMap<String, String>> {
+    async fn branches(&mut self) -> Result<&BTreeMap<String, String>> {
         if self.branches.is_none() {
             if self.api_failed {
-                let driver = self.use_git_fallback()?;
-                let branches = driver.branches()?.clone();
+                let driver = self.use_git_fallback().await?;
+                let branches = driver.branches().await?.clone();
                 self.branches = Some(branches);
             } else {
-                let items = self.api_get_paginated("/repository/branches")?;
+                let items = self.api_get_paginated("/repository/branches").await?;
                 let mut branches = BTreeMap::new();
                 for item in items {
                     if let (Some(name), Some(sha)) =
@@ -189,14 +188,14 @@ impl VcsDriver for GitLabDriver {
         Ok(self.branches.as_ref().unwrap())
     }
 
-    fn tags(&mut self) -> Result<&BTreeMap<String, String>> {
+    async fn tags(&mut self) -> Result<&BTreeMap<String, String>> {
         if self.tags.is_none() {
             if self.api_failed {
-                let driver = self.use_git_fallback()?;
-                let tags = driver.tags()?.clone();
+                let driver = self.use_git_fallback().await?;
+                let tags = driver.tags().await?.clone();
                 self.tags = Some(tags);
             } else {
-                let items = self.api_get_paginated("/repository/tags")?;
+                let items = self.api_get_paginated("/repository/tags").await?;
                 let mut tags = BTreeMap::new();
                 for item in items {
                     if let (Some(name), Some(sha)) =
@@ -211,22 +210,24 @@ impl VcsDriver for GitLabDriver {
         Ok(self.tags.as_ref().unwrap())
     }
 
-    fn composer_information(&mut self, identifier: &str) -> Result<Option<serde_json::Value>> {
+    async fn composer_information(
+        &mut self,
+        identifier: &str,
+    ) -> Result<Option<serde_json::Value>> {
         if let Some(cached) = self.info_cache.get(identifier) {
             return Ok(cached.clone());
         }
-        let content = self.file_content("composer.json", identifier)?;
+        let content = self.file_content("composer.json", identifier).await?;
         let value = content.and_then(|c| serde_json::from_str(&c).ok());
         self.info_cache
             .insert(identifier.to_string(), value.clone());
         Ok(value)
     }
 
-    fn file_content(&self, file: &str, identifier: &str) -> Result<Option<String>> {
+    async fn file_content(&self, file: &str, identifier: &str) -> Result<Option<String>> {
         if self.api_failed {
             return Ok(None);
         }
-        let handle = tokio::runtime::Handle::current();
         let encoded_file = file.replace('/', "%2F");
         let path = format!("/repository/files/{}/raw?ref={}", encoded_file, identifier);
         let url = self.api_url(&path);
@@ -234,25 +235,28 @@ impl VcsDriver for GitLabDriver {
         if let Some(token) = &self.config.gitlab_token {
             req = req.header("PRIVATE-TOKEN", token.as_str());
         }
-        let response = handle.block_on(req.send())?;
+        let response = req.send().await?;
         if response.status().is_success() {
-            Ok(Some(handle.block_on(response.text())?))
+            Ok(Some(response.text().await?))
         } else {
             Ok(None)
         }
     }
 
-    fn change_date(&self, identifier: &str) -> Result<Option<String>> {
+    async fn change_date(&self, identifier: &str) -> Result<Option<String>> {
         if self.api_failed {
             return Ok(None);
         }
-        match self.api_get(&format!("/repository/commits/{identifier}")) {
+        match self
+            .api_get(&format!("/repository/commits/{identifier}"))
+            .await
+        {
             Ok(data) => Ok(data["committed_date"].as_str().map(|s| s.to_string())),
             Err(_) => Ok(None),
         }
     }
 
-    fn dist(&self, identifier: &str) -> Result<Option<DistReference>> {
+    async fn dist(&self, identifier: &str) -> Result<Option<DistReference>> {
         Ok(Some(DistReference {
             dist_type: "zip".to_string(),
             url: format!(
@@ -284,9 +288,9 @@ impl VcsDriver for GitLabDriver {
         &self.url
     }
 
-    fn cleanup(&mut self) -> Result<()> {
+    async fn cleanup(&mut self) -> Result<()> {
         if let Some(driver) = &mut self.git_driver {
-            driver.cleanup()?;
+            driver.cleanup().await?;
         }
         Ok(())
     }