feat: implement pipeline execution with confirmation prompts

- GitLab CI: Execute scripts directly with user confirmation
  - Show all commands before execution
  - Execute sequentially using tokio::process::Command
  - Display progress and status for each command
  - Stop on first failure with exit code
- GitHub Actions: Display job details and recommend using act
- Forgejo Actions: Display job details and recommend using act
- Update README with execution documentation
- Add test fixture for quick verification

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: pepicrft

Cargo.toml

@@ -14,7 +14,7 @@ clap = { version = "4.5", features = ["derive"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_yaml = "0.9"
 serde_json = "1.0"
-tokio = { version = "1.41", features = ["full"] }
+tokio = { version = "1.41", features = ["full", "process"] }
 colored = "2.1"
 anyhow = "1.0"
 inquire = "0.7"

README.md

@@ -22,6 +22,11 @@ magnolia .github/workflows/test.yml
 magnolia .forgejo/workflows/deploy.yml
 ```
 
+### Execution
+
+- **GitLab CI**: Scripts are executed directly on your machine after confirmation. You'll see each command before it runs.
+- **GitHub Actions / Forgejo Actions**: Displays job details and recommends using [act](https://github.com/nektos/act) for local execution with Docker containers.
+
 ## Supported Systems
 
 - GitLab CI (`.gitlab-ci.yml`)

fixtures/test-gitlab.yml

@@ -0,0 +1,5 @@
+test-job:
+  script:
+    - echo "Starting test"
+    - echo "Running step 2"
+    - echo "Test completed successfully"

src/forgejo.rs

@@ -108,14 +108,14 @@ pub async fn run_job_from_file(pipeline_path: &PathBuf, job_name: &str) -> Resul
         .context(format!("Failed to parse {}", pipeline_path.display()))?;
 
     if let Some(job) = workflow.jobs.get(job_name) {
-        println!("{}", format!("Executing job: {}", job_name).green().bold());
+        println!("\n{}", format!("▶ Analyzing job: {}", job_name).cyan().bold());
         println!(
-            "Runs on: {}",
+            "  Runs on: {}",
             job.runs_on.as_deref().unwrap_or("N/A").blue()
         );
 
         if let Some(container) = &job.container {
-            println!("Container: {}", container.dimmed());
+            println!("  Container: {}", container.dimmed());
         }
 
         if let Some(steps) = &job.steps {
@@ -135,11 +135,15 @@ pub async fn run_job_from_file(pipeline_path: &PathBuf, job_name: &str) -> Resul
             }
         }
 
-        println!(
-            "\n{}",
-            "Note: Actual execution is not yet implemented.".yellow()
-        );
-        println!("This would execute the above steps in the specified environment.");
+        println!("\n{}", "─".repeat(60).dimmed());
+        println!("\n{}", "ℹ Forgejo Actions Execution".yellow().bold());
+        println!("Forgejo Actions are compatible with GitHub Actions and use marketplace actions.");
+        println!("\nFor local execution, consider using:");
+        println!("  • {} - Run GitHub Actions locally using Docker", "act".cyan());
+        println!("    Install: brew install act");
+        println!("    Usage: act -j {}", job_name);
+        println!("\n{}", "─".repeat(60).dimmed());
+
         return Ok(());
     }
 

src/github.rs

@@ -96,9 +96,9 @@ pub async fn run_job_from_file(pipeline_path: &PathBuf, job_name: &str) -> Resul
         .context(format!("Failed to parse {}", pipeline_path.display()))?;
 
     if let Some(job) = workflow.jobs.get(job_name) {
-        println!("{}", format!("Executing job: {}", job_name).green().bold());
+        println!("\n{}", format!("▶ Analyzing job: {}", job_name).cyan().bold());
         println!(
-            "Runs on: {}",
+            "  Runs on: {}",
             job.runs_on.as_deref().unwrap_or("N/A").blue()
         );
 
@@ -119,11 +119,16 @@ pub async fn run_job_from_file(pipeline_path: &PathBuf, job_name: &str) -> Resul
             }
         }
 
-        println!(
-            "\n{}",
-            "Note: Actual execution is not yet implemented.".yellow()
-        );
-        println!("This would execute the above steps in the specified environment.");
+        println!("\n{}", "─".repeat(60).dimmed());
+        println!("\n{}", "ℹ GitHub Actions Execution".yellow().bold());
+        println!("GitHub Actions workflows use marketplace actions (e.g., actions/checkout@v4)");
+        println!("and require a GitHub Actions-compatible runtime.");
+        println!("\nFor local execution, consider using:");
+        println!("  • {} - Run GitHub Actions locally using Docker", "act".cyan());
+        println!("    Install: brew install act");
+        println!("    Usage: act -j {}", job_name);
+        println!("\n{}", "─".repeat(60).dimmed());
+
         return Ok(());
     }
 

src/gitlab.rs

@@ -127,27 +127,80 @@ pub async fn run_job_from_file(pipeline_path: &PathBuf, job_name: &str) -> Resul
     if let Some(obj) = ci.as_mapping() {
         if let Some(job) = obj.get(&serde_yaml::Value::String(job_name.to_string())) {
             if let Some(job_map) = job.as_mapping() {
-                println!("{}", format!("Executing job: {}", job_name).green().bold());
+                println!("\n{}", format!("▶ Executing job: {}", job_name).green().bold());
+
+                // Get job metadata
+                let stage = job_map
+                    .get(&serde_yaml::Value::String("stage".to_string()))
+                    .and_then(|v| v.as_str())
+                    .unwrap_or("default");
+
+                let image = job_map
+                    .get(&serde_yaml::Value::String("image".to_string()))
+                    .and_then(|v| v.as_str());
+
+                println!("  Stage: {}", stage.blue());
+                if let Some(img) = image {
+                    println!("  Image: {}", img.dimmed());
+                }
 
                 // Get the script
                 if let Some(script) = job_map.get(&serde_yaml::Value::String("script".to_string()))
                 {
                     if let Some(script_array) = script.as_sequence() {
-                        println!("\n{}", "Script commands:".cyan());
-                        for cmd in script_array {
-                            if let Some(cmd_str) = cmd.as_str() {
-                                println!("  {}", cmd_str.dimmed());
+                        let commands: Vec<String> = script_array
+                            .iter()
+                            .filter_map(|cmd| cmd.as_str().map(String::from))
+                            .collect();
+
+                        if commands.is_empty() {
+                            println!("\n{}", "No script commands found".yellow());
+                            return Ok(());
+                        }
+
+                        println!("\n{}", "Commands to execute:".cyan());
+                        for cmd in &commands {
+                            println!("  $ {}", cmd.dimmed());
+                        }
+
+                        // Ask for confirmation
+                        let confirm = inquire::Confirm::new("Execute these commands?")
+                            .with_default(false)
+                            .prompt()
+                            .unwrap_or(false);
+
+                        if !confirm {
+                            println!("{}", "Execution cancelled".yellow());
+                            return Ok(());
+                        }
+
+                        println!("\n{}", "─".repeat(60).dimmed());
+
+                        // Execute commands
+                        for (i, cmd) in commands.iter().enumerate() {
+                            println!("\n{} {}", format!("[{}/{}]", i + 1, commands.len()).cyan(), cmd.yellow());
+
+                            let status = tokio::process::Command::new("sh")
+                                .arg("-c")
+                                .arg(cmd)
+                                .status()
+                                .await
+                                .context(format!("Failed to execute command: {}", cmd))?;
+
+                            if !status.success() {
+                                let code = status.code().unwrap_or(-1);
+                                println!("\n{}", format!("✗ Command failed with exit code {}", code).red().bold());
+                                anyhow::bail!("Command failed: {}", cmd);
+                            } else {
+                                println!("{}", format!("✓ Command succeeded").green());
                             }
                         }
 
-                        println!(
-                            "\n{}",
-                            "Note: Actual execution is not yet implemented.".yellow()
-                        );
-                        println!(
-                            "This would execute the above commands in the specified environment."
-                        );
+                        println!("\n{}", "─".repeat(60).dimmed());
+                        println!("\n{}", format!("✓ Job '{}' completed successfully", job_name).green().bold());
                     }
+                } else {
+                    println!("\n{}", "No script defined for this job".yellow());
                 }
 
                 return Ok(());