feat: add contract coverage analysis

docs/COMMAND_REFERENCE.md

@@ -115,6 +115,14 @@ starforge contract generate-bindings ./token.wasm --lang rust
 | `--fixture <FILE>` | JSON/TOML contract test suite with fixtures, mocks, and assertions |
 | `--source <FILE>` | Contract source used for generated tests or coverage |
 | `--coverage` | Include source coverage summary |
+| `--coverage-out <FILE>` | Write a dedicated coverage report |
+| `--coverage-format html\|json\|markdown\|text` | Format for `--coverage-out` |
+| `--coverage-goal <PCT>` | Minimum overall coverage percentage |
+| `--function-coverage-goal <PCT>` | Minimum function coverage percentage |
+| `--line-coverage-goal <PCT>` | Minimum line coverage percentage |
+| `--branch-coverage-goal <PCT>` | Minimum branch coverage percentage |
+| `--coverage-ci` | Fail when configured coverage goals are missed |
+| `--coverage-ci-workflow-out <FILE>` | Generate a GitHub Actions coverage workflow |
 | `--report html\|json\|junit` | Write a test report (`junit` is available for fixture suites) |
 | `--testnet` | Validate Soroban testnet integration for the run |
 | `--testnet-dry-run` | Validate testnet configuration without probing RPC health |
@@ -123,11 +131,19 @@ starforge contract generate-bindings ./token.wasm --lang rust
 starforge test --wasm ./target/contract.wasm \
   --fixture ./contract-tests.json --coverage --source ./src/lib.rs --report html
 
+starforge test --wasm ./target/contract.wasm --source ./src/lib.rs \
+  --coverage --coverage-out coverage.html --coverage-format html \
+  --coverage-ci --coverage-goal 85 --branch-coverage-goal 70
+
+starforge test --wasm ./target/contract.wasm --source ./src/lib.rs \
+  --coverage-ci-workflow-out .github/workflows/starforge-coverage.yml
+
 starforge test --wasm ./target/contract.wasm \
   --fixture ./contract-tests.toml --testnet --testnet-dry-run
 ```
 
 Fixture suites support named storage fixtures, mocked contract calls, and assertions such as `state_equals`, `state_exists`, `return_equals`, `event_emitted`, `fee_at_most`, and `mock_called`.
+Coverage analysis tracks Soroban contract functions, line spans, branch paths, uncovered functions, threshold goals, and HTML/JSON/Markdown/text reports.
 
 ---
 

src/commands/backup.rs

@@ -423,7 +423,10 @@ async fn handle_contract_state(args: ContractStateArgs) -> Result<()> {
     p::kv("Contract", &manifest.contract_id);
     p::kv("Network", &manifest.source_network);
     p::kv("Latest ledger", &manifest.latest_ledger.to_string());
-    p::kv("State entries", &manifest.instance_storage.len().to_string());
+    p::kv(
+        "State entries",
+        &manifest.instance_storage.len().to_string(),
+    );
     p::kv("Checksum", &manifest.checksum);
     p::success("Contract state backup created and verified");
     Ok(())

src/commands/bridge.rs

@@ -1,7 +1,13 @@
 use crate::utils::bridge::{
-    load_config, load_transfers, providers::{self, BridgeTransferRequest, TransferStatus},
-    record_transfer, routes::RouteRegistry, save_config, security::SecurityVerifier,
-    state::StateSynchronizer, monitoring::BridgeMonitor, BridgeConfig, BridgeTransferRecord,
+    load_config, load_transfers,
+    monitoring::BridgeMonitor,
+    providers::{self, BridgeTransferRequest, TransferStatus},
+    record_transfer,
+    routes::RouteRegistry,
+    save_config,
+    security::SecurityVerifier,
+    state::StateSynchronizer,
+    BridgeConfig, BridgeTransferRecord,
 };
 use crate::utils::print as p;
 use anyhow::Result;
@@ -255,7 +261,10 @@ fn handle_status(args: StatusArgs) -> Result<()> {
 
     p::kv("Transfer ID", &record.id);
     p::kv("Status", &status.to_string());
-    p::kv("Source", &format!("{} → {}", record.source_network, record.asset));
+    p::kv(
+        "Source",
+        &format!("{} → {}", record.source_network, record.asset),
+    );
     p::kv("Dest", &record.dest_network);
     p::kv("Amount", &record.amount.to_string());
     if let Some(ref tx) = record.tx_hash_source {
@@ -315,10 +324,11 @@ fn handle_routes(args: RoutesArgs) -> Result<()> {
 fn handle_configure(args: ConfigureArgs) -> Result<()> {
     let mut config = load_config()?;
 
-    if args.show || (!args.enable.is_some()
-        && args.default_provider.is_none()
-        && args.max_amount.is_none()
-        && args.require_proof.is_none())
+    if args.show
+        || (args.enable.is_none()
+            && args.default_provider.is_none()
+            && args.max_amount.is_none()
+            && args.require_proof.is_none())
     {
         p::header("Bridge Configuration");
         p::kv("Enabled", &config.enabled.to_string());
@@ -371,7 +381,10 @@ fn handle_sync(args: SyncArgs) -> Result<()> {
     p::kv("Dest ledger", &args.dest_ledger.to_string());
     p::kv("In sync", &sync.is_in_sync(1000).to_string());
     p::kv("Pending", &sync.state().pending_transfers.len().to_string());
-    p::kv("Completed", &sync.state().completed_transfers.len().to_string());
+    p::kv(
+        "Completed",
+        &sync.state().completed_transfers.len().to_string(),
+    );
     p::success("State synchronized");
     Ok(())
 }
@@ -431,7 +444,10 @@ fn handle_monitor(args: MonitorArgs) -> Result<()> {
     }
 
     p::header("Bridge Monitoring");
-    p::kv("Unacknowledged alerts", &monitor.unacknowledged_count().to_string());
+    p::kv(
+        "Unacknowledged alerts",
+        &monitor.unacknowledged_count().to_string(),
+    );
 
     if args.json {
         println!("{}", serde_json::to_string_pretty(monitor.alerts())?);

src/commands/debug.rs

@@ -159,8 +159,7 @@ async fn handle_start(args: StartArgs) -> Result<()> {
                 }
                 sess.set_variables(vars);
 
-                let mut frames = Vec::new();
-                frames.push(debugger::StackFrame {
+                let frames = vec![debugger::StackFrame {
                     function: "contract_init".to_string(),
                     contract_id: Some(cid.clone()),
                     source_location: None,
@@ -173,7 +172,7 @@ async fn handle_start(args: StartArgs) -> Result<()> {
                             value: e.value.clone(),
                         })
                         .collect(),
-                });
+                }];
                 sess.set_call_stack(frames);
                 sess.add_step_history("Debug session started".to_string());
             }
@@ -283,21 +282,33 @@ async fn handle_step(args: StepArgs) -> Result<()> {
             debugger.step_out();
             p::success("Stepping out of current function…");
         }
-        _ => anyhow::bail!("Invalid step direction '{}'. Use 'into', 'over', or 'out'.", args.direction),
+        _ => anyhow::bail!(
+            "Invalid step direction '{}'. Use 'into', 'over', or 'out'.",
+            args.direction
+        ),
     }
 
-    debugger.session.add_step_history(format!("step {}", args.direction));
+    debugger
+        .session
+        .add_step_history(format!("step {}", args.direction));
 
-    simulate_step(debugger).await?;
+    simulate_step(debugger)?;
 
     Ok(())
 }
 
-async fn simulate_step(debugger: &mut Debugger) -> Result<()> {
-    let current_fn = debugger.session.current_function.clone().unwrap_or_default();
+fn simulate_step(debugger: &mut Debugger) -> Result<()> {
+    let current_fn = debugger
+        .session
+        .current_function
+        .clone()
+        .unwrap_or_default();
 
     p::separator();
-    p::kv_accent("Current Depth", &debugger.session.call_stack.len().to_string());
+    p::kv_accent(
+        "Current Depth",
+        &debugger.session.call_stack.len().to_string(),
+    );
     p::kv_accent("Step Count", &debugger.session.step_count.to_string());
 
     if !current_fn.is_empty() {
@@ -449,7 +460,11 @@ async fn handle_stack() -> Result<()> {
     if frames.is_empty() {
         p::info("Call stack is empty.");
     } else {
-        p::header(&format!("Call Stack ({} frame{})", frames.len(), if frames.len() == 1 { "" } else { "s" }));
+        p::header(&format!(
+            "Call Stack ({} frame{})",
+            frames.len(),
+            if frames.len() == 1 { "" } else { "s" }
+        ));
         p::separator();
         for (i, frame) in frames.iter().enumerate() {
             let depth = frames.len() - i;
@@ -587,7 +602,12 @@ async fn handle_ui(args: UiArgs) -> Result<()> {
 async fn manage_breakpoints_interactive() -> Result<()> {
     let selection = Select::new()
         .with_prompt("Breakpoint Action")
-        .items(&["List Breakpoints", "Add Breakpoint", "Remove Breakpoint", "Go Back"])
+        .items(&[
+            "List Breakpoints",
+            "Add Breakpoint",
+            "Remove Breakpoint",
+            "Go Back",
+        ])
         .default(0)
         .interact()?;
 
@@ -596,9 +616,7 @@ async fn manage_breakpoints_interactive() -> Result<()> {
             handle_breakpoint(BreakpointCommands::List).await?;
         }
         1 => {
-            let function: String = Input::new()
-                .with_prompt("Function name")
-                .interact_text()?;
+            let function: String = Input::new().with_prompt("Function name").interact_text()?;
             let contract_id: String = Input::new()
                 .with_prompt("Contract ID (optional)")
                 .allow_empty(true)
@@ -635,5 +653,3 @@ async fn manage_breakpoints_interactive() -> Result<()> {
     }
     Ok(())
 }
-
-

src/commands/deploy.rs

@@ -334,7 +334,8 @@ pub async fn handle(args: DeployArgs) -> Result<()> {
             wasm_size_kb,
             wallet,
             &args.network,
-        ).await;
+        )
+        .await;
     }
 
     if args.simulate {
@@ -422,15 +423,17 @@ pub async fn handle(args: DeployArgs) -> Result<()> {
     let pb = p::progress_bar(3, "Starting deployment steps...");
 
     pb.set_message("Verifying account on-chain...");
-    let account = horizon::fetch_account(&wallet.public_key, &args.network).await.map_err(|e| {
-        pb.abandon();
-        anyhow::anyhow!(
-            "Account not active on {}: {}\nFund it with: starforge wallet fund {}",
-            args.network,
-            e,
-            wallet.name
-        )
-    })?;
+    let account = horizon::fetch_account(&wallet.public_key, &args.network)
+        .await
+        .map_err(|e| {
+            pb.abandon();
+            anyhow::anyhow!(
+                "Account not active on {}: {}\nFund it with: starforge wallet fund {}",
+                args.network,
+                e,
+                wallet.name
+            )
+        })?;
 
     let xlm = account
         .balances
@@ -495,7 +498,12 @@ pub async fn handle(args: DeployArgs) -> Result<()> {
             p::error(&format!("Stellar CLI deployment failed: {}", stderr));
 
             // Automatic rollback safety net: revert to the last good deployment.
-            handle_failed_deploy_rollback(args.no_auto_rollback, previous, &wallet.name, &args.network)?;
+            handle_failed_deploy_rollback(
+                args.no_auto_rollback,
+                previous,
+                &wallet.name,
+                &args.network,
+            )?;
 
             anyhow::bail!("Stellar CLI deployment failed: {}", stderr);
         }
@@ -567,12 +575,18 @@ mod tests {
         let id = format!("C{}", "A".repeat(55));
         assert_eq!(id.len(), 56);
         let stdout = format!("ℹ️  Simulating deploy...\nℹ️  Submitting...\n{}\n", id);
-        assert_eq!(parse_contract_id_from_stdout(&stdout).as_deref(), Some(id.as_str()));
+        assert_eq!(
+            parse_contract_id_from_stdout(&stdout).as_deref(),
+            Some(id.as_str())
+        );
     }
 
     #[test]
     fn returns_none_when_no_contract_id_present() {
-        assert_eq!(parse_contract_id_from_stdout("deploy failed: timeout"), None);
+        assert_eq!(
+            parse_contract_id_from_stdout("deploy failed: timeout"),
+            None
+        );
         // A 56-char wallet public key (G...) must not be mistaken for a contract id.
         let gkey = format!("G{}", "A".repeat(55));
         assert_eq!(gkey.len(), 56);

src/commands/deployments.rs

@@ -305,20 +305,24 @@ async fn handle_verify(args: VerifyArgs) -> Result<()> {
     if let Some(wallet) = cfg.wallets.iter().find(|w| w.name == record.wallet) {
         match horizon::fetch_account(&wallet.public_key, &record.network).await {
             Ok(_) => {
-                report.checks.push(crate::utils::deployment_verify::VerificationCheck {
-                    name: "wallet_active".to_string(),
-                    category: "functionality".to_string(),
-                    status: crate::utils::deployment_verify::CheckStatus::Passed,
-                    detail: format!("Wallet '{}' is active on-chain", record.wallet),
-                });
+                report
+                    .checks
+                    .push(crate::utils::deployment_verify::VerificationCheck {
+                        name: "wallet_active".to_string(),
+                        category: "functionality".to_string(),
+                        status: crate::utils::deployment_verify::CheckStatus::Passed,
+                        detail: format!("Wallet '{}' is active on-chain", record.wallet),
+                    });
             }
             Err(e) => {
-                report.checks.push(crate::utils::deployment_verify::VerificationCheck {
-                    name: "wallet_active".to_string(),
-                    category: "functionality".to_string(),
-                    status: crate::utils::deployment_verify::CheckStatus::Warning,
-                    detail: format!("Could not verify wallet: {}", e),
-                });
+                report
+                    .checks
+                    .push(crate::utils::deployment_verify::VerificationCheck {
+                        name: "wallet_active".to_string(),
+                        category: "functionality".to_string(),
+                        status: crate::utils::deployment_verify::CheckStatus::Warning,
+                        detail: format!("Could not verify wallet: {}", e),
+                    });
             }
         }
     }
@@ -349,7 +353,10 @@ async fn handle_verify(args: VerifyArgs) -> Result<()> {
             .iter()
             .filter(|c| c.status == crate::utils::deployment_verify::CheckStatus::Passed)
             .count();
-        p::kv("Checks passed", &format!("{}/{}", passed_count, report.checks.len()));
+        p::kv(
+            "Checks passed",
+            &format!("{}/{}", passed_count, report.checks.len()),
+        );
     }
 
     if args.report || args.save {

src/commands/mod.rs

@@ -1,8 +1,8 @@
 pub mod analytics;
 pub mod audit;
 pub mod backup;
-pub mod bridge;
 pub mod benchmark;
+pub mod bridge;
 pub mod command_tree;
 pub mod completions;
 pub mod config;

src/commands/monitor.rs

@@ -68,23 +68,29 @@ pub async fn handle(args: MonitorArgs) -> Result<()> {
     println!();
 
     match (&args.contract, &args.wallet) {
-        (Some(contract_id), None) => monitor_contract(
-            contract_id,
-            args.events.as_deref(),
-            args.event_type.as_deref(),
-            args.topic.as_deref(),
-            args.value.as_deref(),
-            network,
-            args.interval,
-            args.follow,
-        ).await,
-        (None, Some(wallet_name)) => monitor_wallet(
-            wallet_name,
-            args.threshold,
-            args.balance_alert,
-            network,
-            args.interval,
-        ).await,
+        (Some(contract_id), None) => {
+            monitor_contract(
+                contract_id,
+                args.events.as_deref(),
+                args.event_type.as_deref(),
+                args.topic.as_deref(),
+                args.value.as_deref(),
+                network,
+                args.interval,
+                args.follow,
+            )
+            .await
+        }
+        (None, Some(wallet_name)) => {
+            monitor_wallet(
+                wallet_name,
+                args.threshold,
+                args.balance_alert,
+                network,
+                args.interval,
+            )
+            .await
+        }
         _ => anyhow::bail!("Specify either --contract or --wallet (but not both)"),
     }
 }