style: run cargo fmt --all

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

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

Author: 2 people

Cargo.lock

@@ -25,6 +25,7 @@ clap = { version = "4", features = ["derive", "env", "cargo"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 serde_yaml = "0.9"
+yaml-rust2 = "0.9"  # YAML parsing with position tracking for dclint
 toml = "0.9"
 log = "0.4"
 env_logger = "0.11"

Cargo.toml

@@ -0,0 +1 @@
+Subproject commit c49696ea1803810813326ed5ec99a4967263a1f4

docker-compose-linter

@@ -1,23 +1,23 @@
-use syncable_cli::analyzer::dependency_parser::{DependencyParser};
-use syncable_cli::analyzer::vulnerability::VulnerabilityChecker;
 use std::path::Path;
+use syncable_cli::analyzer::dependency_parser::DependencyParser;
+use syncable_cli::analyzer::vulnerability::VulnerabilityChecker;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     env_logger::init();
-    
+
     let project_path = Path::new(".");
     println!("🔍 Checking vulnerabilities in: {}", project_path.display());
-    
+
     // Parse dependencies
     let parser = DependencyParser::new();
     let dependencies = parser.parse_all_dependencies(project_path)?;
-    
+
     if dependencies.is_empty() {
         println!("No dependencies found.");
         return Ok(());
     }
-    
+
     // Print found dependencies
     for (lang, deps) in &dependencies {
         println!("\n{:?} dependencies: {}", lang, deps.len());
@@ -28,16 +28,21 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             println!("  ... and {} more", deps.len() - 5);
         }
     }
-    
+
     // Check vulnerabilities
     println!("\n🛡️ Checking for vulnerabilities...");
     let checker = VulnerabilityChecker::new();
-    let report = checker.check_all_dependencies(&dependencies, project_path).await?;
-    
+    let report = checker
+        .check_all_dependencies(&dependencies, project_path)
+        .await?;
+
     println!("\n📊 Vulnerability Report");
-    println!("Checked at: {}", report.checked_at.format("%Y-%m-%d %H:%M:%S UTC"));
+    println!(
+        "Checked at: {}",
+        report.checked_at.format("%Y-%m-%d %H:%M:%S UTC")
+    );
     println!("Total vulnerabilities: {}", report.total_vulnerabilities);
-    
+
     if report.total_vulnerabilities > 0 {
         println!("\nSeverity breakdown:");
         if report.critical_count > 0 {
@@ -52,10 +57,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         if report.low_count > 0 {
             println!("  LOW: {}", report.low_count);
         }
-        
+
         println!("\nVulnerable dependencies:");
         for vuln_dep in &report.vulnerable_dependencies {
-            println!("\n  📦 {} v{} ({:?})", vuln_dep.name, vuln_dep.version, vuln_dep.language);
+            println!(
+                "\n  📦 {} v{} ({:?})",
+                vuln_dep.name, vuln_dep.version, vuln_dep.language
+            );
             for vuln in &vuln_dep.vulnerabilities {
                 println!("    ⚠️  {} [{:?}] - {}", vuln.id, vuln.severity, vuln.title);
                 if let Some(ref cve) = vuln.cve {
@@ -69,6 +77,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     } else {
         println!("\n✅ No known vulnerabilities found!");
     }
-    
+
     Ok(())
-} 
+}

examples/check_vulnerabilities.rs

@@ -1,71 +1,82 @@
 use env_logger;
-use log::{info, error};
+use log::{error, info};
+use std::env;
+use std::path::Path;
 use syncable_cli::analyzer::dependency_parser::{DependencyParser, Language};
 use syncable_cli::analyzer::vulnerability::VulnerabilityChecker;
-use std::path::Path;
-use std::env;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Enable debug logging
     env_logger::Builder::from_default_env()
         .filter_level(log::LevelFilter::Debug)
         .init();
-    
+
     // Get project path from command line args or use current directory
     let args: Vec<String> = env::args().collect();
     let project_path = if args.len() > 1 {
         Path::new(&args[1])
     } else {
         Path::new(".")
     };
-    
-    info!("🔍 Debug Java vulnerability scanning in: {}", project_path.display());
-    
+
+    info!(
+        "🔍 Debug Java vulnerability scanning in: {}",
+        project_path.display()
+    );
+
     // Parse dependencies
     let parser = DependencyParser::new();
     info!("📦 Parsing dependencies...");
     let dependencies = parser.parse_all_dependencies(project_path)?;
-    
+
     if dependencies.is_empty() {
         error!("❌ No dependencies found!");
         info!("Make sure you're in a Java project directory with:");
         info!("  - pom.xml (Maven project)");
         info!("  - build.gradle or build.gradle.kts (Gradle project)");
         return Ok(());
     }
-    
+
     // Show detailed dependency information
     info!("📊 Found dependencies in {} languages:", dependencies.len());
     for (lang, deps) in &dependencies {
         info!("  {:?}: {} dependencies", lang, deps.len());
         if *lang == Language::Java {
             info!("    Java dependencies details:");
             for dep in deps.iter().take(10) {
-                info!("      - {} v{} (source: {:?})", dep.name, dep.version, dep.source);
+                info!(
+                    "      - {} v{} (source: {:?})",
+                    dep.name, dep.version, dep.source
+                );
             }
             if deps.len() > 10 {
                 info!("      ... and {} more", deps.len() - 10);
             }
         }
     }
-    
+
     // Check if Java dependencies were found
     if !dependencies.contains_key(&Language::Java) {
         error!("❌ No Java dependencies detected!");
         info!("Troubleshooting steps:");
         info!("1. Make sure you're in a Java project directory");
         info!("2. For Maven projects: ensure pom.xml exists and has <dependencies> section");
         info!("3. For Gradle projects: ensure build.gradle exists with dependency declarations");
-        info!("4. Run 'mvn dependency:resolve' or 'gradle build' to ensure dependencies are resolved");
+        info!(
+            "4. Run 'mvn dependency:resolve' or 'gradle build' to ensure dependencies are resolved"
+        );
         return Ok(());
     }
-    
+
     // Check vulnerabilities
     info!("🛡️ Checking for vulnerabilities...");
     let checker = VulnerabilityChecker::new();
-    
-    match checker.check_all_dependencies(&dependencies, project_path).await {
+
+    match checker
+        .check_all_dependencies(&dependencies, project_path)
+        .await
+    {
         Ok(report) => {
             info!("✅ Vulnerability scan completed successfully!");
             info!("📊 Results:");
@@ -74,12 +85,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             info!("  High: {}", report.high_count);
             info!("  Medium: {}", report.medium_count);
             info!("  Low: {}", report.low_count);
-            
+
             if report.total_vulnerabilities > 0 {
                 info!("🚨 Vulnerable dependencies:");
                 for vuln_dep in &report.vulnerable_dependencies {
-                    info!("  - {} v{} ({} vulnerabilities)", 
-                          vuln_dep.name, vuln_dep.version, vuln_dep.vulnerabilities.len());
+                    info!(
+                        "  - {} v{} ({} vulnerabilities)",
+                        vuln_dep.name,
+                        vuln_dep.version,
+                        vuln_dep.vulnerabilities.len()
+                    );
                     for vuln in &vuln_dep.vulnerabilities {
                         info!("    • {} [{:?}] - {}", vuln.id, vuln.severity, vuln.title);
                     }
@@ -89,7 +104,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 info!("This could mean:");
                 info!("  - Your dependencies are up to date and secure");
                 info!("  - The vulnerability scanner (grype) didn't find any issues");
-                info!("  - The dependency versions couldn't be matched with vulnerability databases");
+                info!(
+                    "  - The dependency versions couldn't be matched with vulnerability databases"
+                );
             }
         }
         Err(e) => {
@@ -100,6 +117,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             info!("  - Dependencies not resolved: run 'mvn dependency:resolve'");
         }
     }
-    
+
     Ok(())
-} 
+}