style: fix formatting for all source files

Author: echobt

src/auth.rs

@@ -7,10 +7,7 @@ use axum::{
 use uuid::Uuid;
 
 #[allow(dead_code)]
-pub async fn auth_middleware(
-    request: Request,
-    next: Next,
-) -> Result<Response, StatusCode> {
+pub async fn auth_middleware(request: Request, next: Next) -> Result<Response, StatusCode> {
     let token = request
         .extensions()
         .get::<Option<String>>()
@@ -51,10 +48,9 @@ pub async fn auth_middleware(
 
 fn inject_request_id(response: &mut Response) {
     let id = Uuid::new_v4().to_string();
-    response.headers_mut().insert(
-        "x-request-id",
-        id.parse().unwrap(),
-    );
+    response
+        .headers_mut()
+        .insert("x-request-id", id.parse().unwrap());
 }
 
 /// Simple token check function for endpoints that check auth directly.

src/cleanup.rs

@@ -70,7 +70,9 @@ mod tests {
         let tmp = tempfile::tempdir().unwrap();
         let dir = tmp.path().join("session-test");
         tokio::fs::create_dir_all(&dir).await.unwrap();
-        tokio::fs::write(dir.join("file.txt"), "data").await.unwrap();
+        tokio::fs::write(dir.join("file.txt"), "data")
+            .await
+            .unwrap();
         assert!(dir.exists());
         remove_work_dir(&dir).await;
         assert!(!dir.exists());

src/config.rs

@@ -45,16 +45,29 @@ impl Config {
 
     pub fn print_banner(&self) {
         tracing::info!("╔══════════════════════════════════════════════════╗");
-        tracing::info!("║           term-executor v{}              ║", env!("CARGO_PKG_VERSION"));
+        tracing::info!(
+            "║           term-executor v{}              ║",
+            env!("CARGO_PKG_VERSION")
+        );
         tracing::info!("╠══════════════════════════════════════════════════╣");
         tracing::info!("║  Port:              {:<28}║", self.port);
-        tracing::info!("║  Auth:              {:<28}║", if self.auth_token.is_some() { "enabled" } else { "disabled" });
+        tracing::info!(
+            "║  Auth:              {:<28}║",
+            if self.auth_token.is_some() {
+                "enabled"
+            } else {
+                "disabled"
+            }
+        );
         tracing::info!("║  Max concurrent:    {:<28}║", self.max_concurrent_evals);
         tracing::info!("║  Session TTL:       {:<25}s ║", self.session_ttl_secs);
         tracing::info!("║  Clone timeout:     {:<25}s ║", self.clone_timeout_secs);
         tracing::info!("║  Agent timeout:     {:<25}s ║", self.agent_timeout_secs);
         tracing::info!("║  Test timeout:      {:<25}s ║", self.test_timeout_secs);
-        tracing::info!("║  Workspace:         {:<28}║", self.workspace_base.display());
+        tracing::info!(
+            "║  Workspace:         {:<28}║",
+            self.workspace_base.display()
+        );
         tracing::info!("╚══════════════════════════════════════════════════╝");
     }
 }

src/executor.rs

@@ -155,7 +155,12 @@ async fn run_eval(
         }
 
         let repo_dir = work_dir.join("repo");
-        clone_repo(&swe_task.workspace.repo, &repo_dir, config.clone_timeout_secs).await?;
+        clone_repo(
+            &swe_task.workspace.repo,
+            &repo_dir,
+            config.clone_timeout_secs,
+        )
+        .await?;
 
         if let Some(ref commit) = swe_task.workspace.base_commit {
             checkout_commit(&repo_dir, commit, config.clone_timeout_secs).await?;

src/handlers.rs

@@ -128,10 +128,7 @@ async fn evaluate(
     }
 
     if payload.task_url.is_empty() {
-        return Err((
-            StatusCode::BAD_REQUEST,
-            "task_url is required".to_string(),
-        ));
+        return Err((StatusCode::BAD_REQUEST, "task_url is required".to_string()));
     }
 
     if payload.agent_code.is_empty() {
@@ -148,8 +145,7 @@ async fn evaluate(
             StatusCode::SERVICE_UNAVAILABLE,
             format!(
                 "At capacity ({}/{}). Try again later.",
-                state.config.max_concurrent_evals,
-                state.config.max_concurrent_evals
+                state.config.max_concurrent_evals, state.config.max_concurrent_evals
             ),
         ));
     }
@@ -208,9 +204,7 @@ struct EvalListEntry {
     created_at: String,
 }
 
-async fn list_evals(
-    State(state): State<Arc<AppState>>,
-) -> Json<Vec<EvalListEntry>> {
+async fn list_evals(State(state): State<Arc<AppState>>) -> Json<Vec<EvalListEntry>> {
     let sessions = state.sessions.list_sessions();
     Json(
         sessions

src/metrics.rs

@@ -30,11 +30,18 @@ impl Metrics {
 
     pub fn finish_eval(&self, passed: Option<bool>, duration_ms: u64) {
         self.evals_active.fetch_sub(1, Ordering::Relaxed);
-        self.evals_duration_sum_ms.fetch_add(duration_ms, Ordering::Relaxed);
+        self.evals_duration_sum_ms
+            .fetch_add(duration_ms, Ordering::Relaxed);
         match passed {
-            Some(true) => { self.evals_passed.fetch_add(1, Ordering::Relaxed); }
-            Some(false) => { self.evals_failed.fetch_add(1, Ordering::Relaxed); }
-            None => { self.evals_failed.fetch_add(1, Ordering::Relaxed); }
+            Some(true) => {
+                self.evals_passed.fetch_add(1, Ordering::Relaxed);
+            }
+            Some(false) => {
+                self.evals_failed.fetch_add(1, Ordering::Relaxed);
+            }
+            None => {
+                self.evals_failed.fetch_add(1, Ordering::Relaxed);
+            }
         }
     }
 

src/task.rs

@@ -104,7 +104,12 @@ pub fn parse_task(task_dir: &Path) -> Result<SweForgeTask> {
     // Load from tests/ directory
     let tests_dir = task_dir.join("tests");
     if tests_dir.exists() {
-        load_tests_recursive(&tests_dir, &tests_dir, &mut test_scripts, &mut test_source_files)?;
+        load_tests_recursive(
+            &tests_dir,
+            &tests_dir,
+            &mut test_scripts,
+            &mut test_source_files,
+        )?;
     }
 
     // Load from checks.txt (alternative flat format)
@@ -121,7 +126,10 @@ pub fn parse_task(task_dir: &Path) -> Result<SweForgeTask> {
             test_scripts.push((name, content));
         }
         if !test_scripts.is_empty() {
-            info!("Loaded {} test commands from checks.txt", test_scripts.len());
+            info!(
+                "Loaded {} test commands from checks.txt",
+                test_scripts.len()
+            );
         }
     }
 
@@ -227,12 +235,14 @@ version: "v2.31.0"
         std::fs::write(
             dir.join("workspace.yaml"),
             "repo: https://github.com/test/repo\nversion: v1.0\n",
-        ).unwrap();
+        )
+        .unwrap();
         std::fs::write(dir.join("prompt.md"), "Fix the bug").unwrap();
         std::fs::write(
             dir.join("checks.txt"),
             "# comment\npython -m pytest tests/\ncargo test\n",
-        ).unwrap();
+        )
+        .unwrap();
 
         let task = parse_task(dir).unwrap();
         assert_eq!(task.test_scripts.len(), 2);