feat: consolidate AI rules into unified AGENTS.md (#501)

- Merge all AI rules from .rules.md, .cursorrules, and CLAUDE.md into AGENTS.md
- Add competitor keyword prohibition rules (minio, ceph, swift, etc.)
- Simplify rules by removing overly detailed code examples
- Integrate new development principles as highest priority
- Remove old tool-specific rule files
- Fix clippy warnings for format string improvements

crates/ahm/tests/endpoint_index_test.rs

@@ -24,7 +24,7 @@ async fn test_endpoint_index_settings() -> anyhow::Result<()> {
     let temp_dir = TempDir::new()?;
 
     // create test disk paths
-    let disk_paths: Vec<_> = (0..4).map(|i| temp_dir.path().join(format!("disk{}", i))).collect();
+    let disk_paths: Vec<_> = (0..4).map(|i| temp_dir.path().join(format!("disk{i}"))).collect();
 
     for path in &disk_paths {
         tokio::fs::create_dir_all(path).await?;
@@ -60,9 +60,9 @@ async fn test_endpoint_index_settings() -> anyhow::Result<()> {
 
     // validate all endpoint indexes are in valid range
     for (i, ep) in endpoints.iter().enumerate() {
-        assert_eq!(ep.pool_idx, 0, "Endpoint {} pool_idx should be 0", i);
-        assert_eq!(ep.set_idx, 0, "Endpoint {} set_idx should be 0", i);
-        assert_eq!(ep.disk_idx, i as i32, "Endpoint {} disk_idx should be {}", i, i);
+        assert_eq!(ep.pool_idx, 0, "Endpoint {i} pool_idx should be 0");
+        assert_eq!(ep.set_idx, 0, "Endpoint {i} set_idx should be 0");
+        assert_eq!(ep.disk_idx, i as i32, "Endpoint {i} disk_idx should be {i}");
         println!(
             "Endpoint {} indices are valid: pool={}, set={}, disk={}",
             i, ep.pool_idx, ep.set_idx, ep.disk_idx

crates/ahm/tests/integration_tests.rs

@@ -270,15 +270,15 @@ async fn test_performance_impact_measurement() {
     };
 
     println!("Performance impact measurement:");
-    println!("  Baseline duration: {:?}", baseline_duration);
-    println!("  With scanner duration: {:?}", with_scanner_duration);
-    println!("  Overhead: {} ms", overhead_ms);
-    println!("  Impact percentage: {:.2}%", impact_percentage);
+    println!("  Baseline duration: {baseline_duration:?}");
+    println!("  With scanner duration: {with_scanner_duration:?}");
+    println!("  Overhead: {overhead_ms} ms");
+    println!("  Impact percentage: {impact_percentage:.2}%");
     println!("  Meets optimization goals: {}", benchmark.meets_optimization_goals());
 
     // Verify optimization target (business impact < 10%)
     // Note: In real environment this test may need longer time and real load
-    assert!(impact_percentage < 50.0, "Performance impact too high: {:.2}%", impact_percentage);
+    assert!(impact_percentage < 50.0, "Performance impact too high: {impact_percentage:.2}%");
 
     io_monitor.stop().await;
 }
@@ -308,7 +308,7 @@ async fn test_concurrent_scanner_operations() {
             tokio::spawn(async move {
                 for _i in 0..5 {
                     if let Err(e) = scanner.force_save_checkpoint().await {
-                        eprintln!("Checkpoint save failed: {}", e);
+                        eprintln!("Checkpoint save failed: {e}");
                     }
                     tokio::time::sleep(Duration::from_millis(100)).await;
                 }

crates/ahm/tests/optimized_scanner_tests.rs

@@ -319,14 +319,14 @@ async fn test_optimized_performance_characteristics() {
 
     // Create several test objects
     for i in 0..10 {
-        let object_name = format!("perf-object-{}", i);
+        let object_name = format!("perf-object-{i}");
         let test_data = vec![b'A' + (i % 26) as u8; 1024 * (i + 1)]; // Variable size objects
         let mut put_reader = PutObjReader::from_vec(test_data);
         let object_opts = rustfs_ecstore::store_api::ObjectOptions::default();
         ecstore
             .put_object(bucket_name, &object_name, &mut put_reader, &object_opts)
             .await
-            .unwrap_or_else(|_| panic!("Failed to create object {}", object_name));
+            .unwrap_or_else(|_| panic!("Failed to create object {object_name}"));
     }
 
     // Create optimized scanner
@@ -340,7 +340,7 @@ async fn test_optimized_performance_characteristics() {
     let scan_result = scanner.scan_cycle().await;
     let scan_duration = start_time.elapsed();
 
-    println!("Optimized scan completed in: {:?}", scan_duration);
+    println!("Optimized scan completed in: {scan_duration:?}");
     assert!(scan_result.is_ok(), "Performance scan should succeed");
 
     // Verify the scan was reasonably fast (should be faster than old concurrent scanner)
@@ -359,11 +359,11 @@ async fn test_optimized_performance_characteristics() {
     let _scan_result2 = scanner.scan_cycle().await;
     let scan_duration2 = start_time2.elapsed();
 
-    println!("Second optimized scan completed in: {:?}", scan_duration2);
+    println!("Second optimized scan completed in: {scan_duration2:?}");
 
     // Second scan should be similar or faster due to caching
     let performance_ratio = scan_duration2.as_millis() as f64 / scan_duration.as_millis() as f64;
-    println!("Performance ratio (second/first): {:.2}", performance_ratio);
+    println!("Performance ratio (second/first): {performance_ratio:.2}");
 
     // Clean up
     let _ = std::fs::remove_dir_all(std::path::Path::new(TEST_DIR_PERF));
@@ -404,7 +404,7 @@ async fn test_optimized_load_balancing_and_throttling() {
     ];
 
     for (expected_level, latency, qps, error_rate, connections) in load_scenarios {
-        println!("Testing load scenario: {:?}", expected_level);
+        println!("Testing load scenario: {expected_level:?}");
 
         // Update business metrics to simulate load
         node_scanner
@@ -416,7 +416,7 @@ async fn test_optimized_load_balancing_and_throttling() {
 
         // Get current load level
         let current_level = io_monitor.get_business_load_level().await;
-        println!("Detected load level: {:?}", current_level);
+        println!("Detected load level: {current_level:?}");
 
         // Get throttling decision
         let _current_metrics = io_monitor.get_current_metrics().await;

crates/ahm/tests/scanner_optimization_tests.rs

@@ -298,7 +298,7 @@ async fn test_scanner_performance_impact() {
     let throttle_stats = throttler.get_throttle_stats().await;
 
     println!("Performance test results:");
-    println!("  Load level: {:?}", load_level);
+    println!("  Load level: {load_level:?}");
     println!("  Throttle decisions: {}", throttle_stats.total_decisions);
     println!("  Average delay: {:?}", throttle_stats.average_delay);