feat (cli): Loading animation for deployments and builds (#724)

## Description
Added a spinner as sign of loading animation for deployments in CLI 

## Related Issues
#705 

Closes #705 

## Checklist when merging to main
<!-- Mark items with "x" when completed -->

- [x] No compiler warnings (if applicable)
- [x] Code is formatted with `rustfmt`
- [x] No useless or dead code (if applicable)
- [x] Code is easy to understand
- [x] Doc comments are used for all functions, enums, structs, and
fields (where appropriate)
- [x] All tests pass
- [x] Performance has not regressed (assuming change was not to fix a
bug)
- [x] Version number has been updated in `helix-cli/Cargo.toml` and
`helixdb/Cargo.toml`

## Additional Notes
Here is a quick video 
[Screencast from 2025-11-25
14-25-14.webm](https://github.com/user-attachments/assets/c021588a-d56b-4a5c-90ff-b212a41f5f2b)

<!-- greptile_comment -->

<h2>Greptile Overview</h2>

<h3>Greptile Summary</h3>


Implemented loading spinner animation for CLI deployment operations to
address user feedback that the terminal appeared frozen during builds.

**Key changes:**
- Added `Spinner` struct in `utils.rs` with async animation using tokio
- Integrated spinner around Docker build operations in `build.rs`
- Added spinners for both build and deployment phases in `push.rs` with
provider-specific messages
- Removed redundant status print statements from `docker.rs` to avoid
interfering with spinner

**Implementation details:**
- Spinner runs as a tokio task with braille pattern animation frames
- Uses `Arc<Mutex<String>>` for thread-safe message updates
- Properly cleans up via Drop trait to prevent resource leaks
- Supports dynamic message updates during long operations

<details><summary><h3>Important Files Changed</h3></summary>



File Analysis



| Filename | Score | Overview |
|----------|-------|----------|
| helix-cli/src/utils.rs | 4/5 | Added `Spinner` struct with async
animation loop using tokio, includes proper cleanup via Drop trait |
| helix-cli/src/commands/build.rs | 5/5 | Added spinner for Docker image
build step, wrapping `build_image` call with start/stop |
| helix-cli/src/commands/push.rs | 4/5 | Added spinners for build and
deployment phases, with dynamic messages for different cloud providers |
| helix-cli/src/docker.rs | 5/5 | Removed status print statements from
`build_image`, delegating user feedback to spinner in calling code |

</details>


</details>


<details><summary><h3>Sequence Diagram</h3></summary>

```mermaid
sequenceDiagram
    participant User
    participant BuildCmd as build.rs
    participant PushCmd as push.rs
    participant Spinner
    participant Docker as docker.rs
    participant CloudProvider

    Note over User,CloudProvider: Build Command Flow
    User->>BuildCmd: helix build
    BuildCmd->>Spinner: new("DOCKER", "Building...")
    BuildCmd->>Spinner: start()
    activate Spinner
    Note right of Spinner: Tokio task spawned<br/>Animation loop running
    BuildCmd->>Docker: build_image()
    Docker-->>BuildCmd: Result
    BuildCmd->>Spinner: stop()
    deactivate Spinner
    Note right of Spinner: Task aborted<br/>Line cleared
    BuildCmd-->>User: Success message

    Note over User,CloudProvider: Push Command Flow (Cloud)
    User->>PushCmd: helix push
    PushCmd->>Spinner: new("BUILD", "Building instance...")
    PushCmd->>Spinner: start()
    activate Spinner
    PushCmd->>BuildCmd: run()
    BuildCmd->>Docker: build_image()
    Docker-->>BuildCmd: Result
    BuildCmd-->>PushCmd: MetricsData
    PushCmd->>Spinner: stop()
    deactivate Spinner
    
    PushCmd->>Spinner: new("DEPLOY", "Deploying instance...")
    PushCmd->>Spinner: start()
    activate Spinner
    PushCmd->>Spinner: update("Deploying to Fly.io/ECR/Helix...")
    Note right of Spinner: Message updates<br/>while animating
    PushCmd->>CloudProvider: deploy()
    CloudProvider-->>PushCmd: Result
    PushCmd->>Spinner: stop()
    deactivate Spinner
    PushCmd-->>User: Success message
```
</details>


<!-- greptile_other_comments_section -->

<!-- /greptile_comment -->

Author: xav-db

helix-cli/src/commands/build.rs

@@ -4,7 +4,7 @@ use crate::metrics_sender::MetricsSender;
 use crate::project::{ProjectContext, get_helix_repo_cache};
 use crate::utils::{
     copy_dir_recursive_excluding, diagnostic_source, helixc_utils::collect_hx_files, print_status,
-    print_success,
+    print_success, Spinner,
 };
 use eyre::Result;
 use std::time::Instant;
@@ -90,7 +90,10 @@ pub async fn run(instance_name: String, metrics_sender: &MetricsSender) -> Resul
         DockerManager::check_runtime_available(runtime)?;
         let docker = DockerManager::new(&project);
 
+        let mut spinner = Spinner::new("DOCKER", "Building Docker image...");
+        spinner.start();
         docker.build_image(&instance_name, instance_config.docker_build_target())?;
+        spinner.stop();
     }
 
     print_success(&format!("Instance '{instance_name}' built successfully"));

helix-cli/src/commands/push.rs

@@ -6,7 +6,7 @@ use crate::config::{CloudConfig, InstanceInfo};
 use crate::docker::DockerManager;
 use crate::metrics_sender::MetricsSender;
 use crate::project::ProjectContext;
-use crate::utils::{print_status, print_success};
+use crate::utils::{print_status, print_success, Spinner};
 use eyre::Result;
 use std::time::Instant;
 
@@ -136,7 +136,11 @@ async fn push_cloud_instance(
 
     let metrics_data = if instance_config.should_build_docker_image() {
         // Build happens, get metrics data from build
-        crate::commands::build::run(instance_name.to_string(), metrics_sender).await?
+        let mut spinner = Spinner::new("BUILD", "Building instance...");
+        spinner.start();
+        let result = crate::commands::build::run(instance_name.to_string(), metrics_sender).await;
+        spinner.stop();
+        result?
     } else {
         // No build, use lightweight parsing
         parse_queries_for_metrics(project)?
@@ -149,8 +153,11 @@ async fn push_cloud_instance(
     // 3. Triggering deployment on the cloud
 
     let config = project.config.cloud.get(instance_name).unwrap();
+    let mut deploy_spinner = Spinner::new("DEPLOY", "Deploying instance...");
+    deploy_spinner.start();
     match config {
         CloudConfig::FlyIo(config) => {
+            deploy_spinner.update("Deploying to Fly.io...");
             let fly = FlyManager::new(project, config.auth_type.clone()).await?;
             let docker = DockerManager::new(project);
             // Get the correct image name from docker compose project name
@@ -160,6 +167,7 @@ async fn push_cloud_instance(
                 .await?;
         }
         CloudConfig::Ecr(config) => {
+            deploy_spinner.update("Deploying to ECR...");
             let ecr = EcrManager::new(project, config.auth_type.clone()).await?;
             let docker = DockerManager::new(project);
             // Get the correct image name from docker compose project name
@@ -169,10 +177,12 @@ async fn push_cloud_instance(
                 .await?;
         }
         CloudConfig::Helix(_config) => {
+            deploy_spinner.update("Deploying to Helix...");
             let helix = HelixManager::new(project);
             helix.deploy(None, instance_name.to_string()).await?;
         }
     }
+    deploy_spinner.stop();
 
     print_status("UPLOAD", &format!("Uploading to cluster: {cluster_id}"));
 

helix-cli/src/docker.rs

@@ -547,15 +547,14 @@ networks:
             self.runtime.label(),
             &format!("Building image for instance '{instance_name}'..."),
         );
-
         let output = self.run_compose_command(instance_name, vec!["build"])?;
 
         if !output.status.success() {
             let stderr = String::from_utf8_lossy(&output.stderr);
             return Err(eyre!("{} build failed:\n{stderr}", self.runtime.binary()));
         }
-
         print_status(self.runtime.label(), "Image built successfully");
+
         Ok(())
     }
 

helix-cli/src/utils.rs

@@ -3,6 +3,10 @@ use color_eyre::owo_colors::OwoColorize;
 use eyre::{Result, eyre};
 use helix_db::helixc::parser::types::HxFile;
 use std::{borrow::Cow, fs, path::Path};
+use tokio::sync::oneshot;
+use tokio::time::Duration;
+use std::io::IsTerminal;
+
 
 const IGNORES: [&str; 3] = ["target", ".git", ".helix"];
 
@@ -407,3 +411,74 @@ pub mod helixc_utils {
         false
     }
 }
+
+pub struct Spinner {
+    message: std::sync::Arc<std::sync::Mutex<String>>,
+    prefix: String,
+    stop_tx: Option<oneshot::Sender<()>>,
+    handle: Option<tokio::task::JoinHandle<()>>,
+}
+
+impl Spinner {
+    pub fn new(prefix: &str, message: &str) -> Self {
+        Self {
+            message: std::sync::Arc::new(std::sync::Mutex::new(message.to_string())),
+            prefix: prefix.to_string(),
+            stop_tx: None,
+            handle: None,
+        }
+    }
+    // function that starts the spinner
+    pub fn start(&mut self) {
+        if !std::io::stdout().is_terminal() {
+            return; // skip animation for non-interactive terminals
+        }
+        let message = self.message.clone();
+        let prefix = self.prefix.clone();
+        let (tx, mut rx) = oneshot::channel::<()>();
+
+        let handle = tokio::spawn(async move {
+            let frames = vec!["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+            let mut frame_idx = 0;
+            loop {
+                if rx.try_recv().is_ok() {
+                    break;
+                }
+                let frame = frames[frame_idx % frames.len()];
+                let msg = message.lock().unwrap().clone();
+                print!(
+                    "\r{} {frame} {msg}",
+                    format!("[{prefix}]").blue().bold()
+                );
+                std::io::Write::flush(&mut std::io::stdout()).unwrap();
+                frame_idx += 1;
+                tokio::time::sleep(Duration::from_millis(100)).await;
+            }
+        });
+        self.handle = Some(handle);
+        self.stop_tx = Some(tx);
+    }
+    // function that Stops the spinner
+    pub fn stop(&mut self) {
+        if let Some(tx) = self.stop_tx.take() {
+            let _ = tx.send(());
+        }
+        if let Some(handle) = self.handle.take() {
+            handle.abort();
+        }
+        print!("\r");
+        std::io::Write::flush(&mut std::io::stdout()).unwrap();
+    }
+    /// function that updates the message
+    pub fn update(&mut self, message: &str) {
+        if let Ok(mut msg) = self.message.lock() {
+            *msg = message.to_string();
+        }
+    }
+}
+
+impl Drop for Spinner {
+    fn drop(&mut self) {
+        self.stop();
+    }
+}