claude-flow-novice 2.18.5 → 2.18.6

package/.claude/skills/cfn-transparency-middleware/src/api_handler.rs

@@ -0,0 +1,318 @@
+use anyhow::{Result, anyhow};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// Represents an HTTP request
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Request {
+    pub method: String,
+    pub path: String,
+    pub body: Option<String>,
+    pub headers: HashMap<String, String>,
+}
+
+impl Request {
+    pub fn new(method: &str, path: &str) -> Self {
+        Self {
+            method: method.to_string(),
+            path: path.to_string(),
+            body: None,
+            headers: HashMap::new(),
+        }
+    }
+
+    pub fn with_body(mut self, body: String) -> Self {
+        self.body = Some(body);
+        self
+    }
+
+    pub fn with_header(mut self, key: &str, value: &str) -> Self {
+        self.headers.insert(key.to_string(), value.to_string());
+        self
+    }
+}
+
+/// Represents an HTTP response
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Response {
+    pub status_code: u16,
+    pub body: String,
+    pub headers: HashMap<String, String>,
+}
+
+impl Response {
+    pub fn new(status_code: u16) -> Self {
+        Self {
+            status_code,
+            body: String::new(),
+            headers: HashMap::new(),
+        }
+    }
+
+    pub fn with_body(mut self, body: String) -> Self {
+        self.body = body;
+        self
+    }
+
+    pub fn with_header(mut self, key: &str, value: &str) -> Self {
+        self.headers.insert(key.to_string(), value.to_string());
+        self
+    }
+
+    pub fn ok(body: String) -> Self {
+        Self::new(200)
+            .with_body(body)
+            .with_header("Content-Type", "application/json")
+    }
+
+    pub fn created(body: String) -> Self {
+        Self::new(201)
+            .with_body(body)
+            .with_header("Content-Type", "application/json")
+    }
+
+    pub fn bad_request(body: String) -> Self {
+        Self::new(400)
+            .with_body(body)
+            .with_header("Content-Type", "application/json")
+    }
+
+    pub fn not_found(body: String) -> Self {
+        Self::new(404)
+            .with_body(body)
+            .with_header("Content-Type", "application/json")
+    }
+
+    pub fn internal_error(body: String) -> Self {
+        Self::new(500)
+            .with_body(body)
+            .with_header("Content-Type", "application/json")
+    }
+}
+
+/// API Response enum for handler returns
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum ApiResponse {
+    Success(Response),
+    Error(String),
+}
+
+impl ApiResponse {
+    pub fn into_response(self) -> Response {
+        match self {
+            ApiResponse::Success(response) => response,
+            ApiResponse::Error(error) => Response::internal_error(
+                format!(r#"{{"error": "{}"}}"#, error)
+            ),
+        }
+    }
+}
+
+/// Type alias for request handlers
+pub type RouteHandler = fn(Request) -> Result<Response>;
+
+/// Main API Handler struct
+pub struct ApiHandler {
+    routes: HashMap<String, HashMap<String, RouteHandler>>,
+}
+
+impl ApiHandler {
+    /// Creates a new ApiHandler instance
+    pub fn new() -> Self {
+        Self {
+            routes: HashMap::new(),
+        }
+    }
+
+    /// Handles an incoming request
+    pub fn handle_request(&self, method: &str, path: &str, body: Option<&str>) -> Result<ApiResponse> {
+        // Build request object
+        let mut request = Request::new(method, path);
+        if let Some(body_str) = body {
+            request = request.with_body(body_str.to_string());
+        }
+
+        // Find matching route
+        if let Some(method_routes) = self.routes.get(method) {
+            // Exact path match
+            if let Some(handler) = method_routes.get(path) {
+                return match handler(request) {
+                    Ok(response) => Ok(ApiResponse::Success(response)),
+                    Err(e) => Ok(ApiResponse::Error(e.to_string())),
+                };
+            } else {
+                // Try to match as a pattern (simple wildcard support)
+                for (route_path, handler) in method_routes {
+                    if self.path_matches(route_path, path) {
+                        return match handler(request) {
+                            Ok(response) => Ok(ApiResponse::Success(response)),
+                            Err(e) => Ok(ApiResponse::Error(e.to_string())),
+                        };
+                    }
+                }
+            }
+        }
+
+        // If no route found
+        Ok(ApiResponse::Error(
+            format!("Route not found: {} {}", method, path)
+        ))
+    }
+
+    /// Adds a route to the handler
+    pub fn add_route(&mut self, method: &str, path: &str, handler: RouteHandler) -> Result<()> {
+        let method = method.to_uppercase();
+        let path = path.to_string();
+
+        if !self.routes.contains_key(&method) {
+            self.routes.insert(method.clone(), HashMap::new());
+        }
+
+        let method_routes = self.routes.get_mut(&method)
+            .ok_or_else(|| anyhow!("Failed to get method routes"))?;
+
+        method_routes.insert(path, handler);
+
+        Ok(())
+    }
+
+    /// Gets all registered routes
+    pub fn get_routes(&self) -> Vec<(String, String)> {
+        let mut routes = Vec::new();
+
+        for (method, method_routes) in &self.routes {
+            for path in method_routes.keys() {
+                routes.push((method.clone(), path.clone()));
+            }
+        }
+
+        routes.sort();
+        routes
+    }
+
+    /// Simple path matching with support for wildcards
+    fn path_matches(&self, route: &str, path: &str) -> bool {
+        // Support simple wildcard at the end
+        if route.ends_with('*') {
+            let base = &route[..route.len() - 1];
+            path.starts_with(base)
+        } else {
+            route == path
+        }
+    }
+}
+
+impl Default for ApiHandler {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+// Unit tests
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_api_handler_creation() {
+        let handler = ApiHandler::new();
+        assert_eq!(handler.get_routes().len(), 0);
+    }
+
+    #[test]
+    fn test_add_route() {
+        let mut handler = ApiHandler::new();
+
+        fn test_handler(_req: Request) -> Result<Response> {
+            Ok(Response::ok("test".to_string()))
+        }
+
+        handler.add_route("GET", "/test", test_handler).unwrap();
+
+        let routes = handler.get_routes();
+        assert_eq!(routes.len(), 1);
+        assert_eq!(routes[0], ("GET".to_string(), "/test".to_string()));
+    }
+
+    #[test]
+    fn test_handle_request() {
+        let mut handler = ApiHandler::new();
+
+        fn test_handler(req: Request) -> Result<Response> {
+            Ok(Response::ok(format!("Handled: {} {}", req.method, req.path)))
+        }
+
+        handler.add_route("GET", "/test", test_handler).unwrap();
+
+        let response = handler.handle_request("GET", "/test", None).unwrap();
+
+        match response {
+            ApiResponse::Success(resp) => {
+                assert_eq!(resp.status_code, 200);
+                assert_eq!(resp.body, "Handled: GET /test");
+            },
+            ApiResponse::Error(_) => panic!("Expected success response"),
+        }
+    }
+
+    #[test]
+    fn test_handle_request_not_found() {
+        let handler = ApiHandler::new();
+
+        let response = handler.handle_request("GET", "/nonexistent", None).unwrap();
+
+        match response {
+            ApiResponse::Success(_) => panic!("Expected error response"),
+            ApiResponse::Error(error) => {
+                assert!(error.contains("Route not found"));
+            },
+        }
+    }
+
+    #[test]
+    fn test_request_builder() {
+        let request = Request::new("GET", "/test")
+            .with_body("test body".to_string())
+            .with_header("Content-Type", "application/json");
+
+        assert_eq!(request.method, "GET");
+        assert_eq!(request.path, "/test");
+        assert_eq!(request.body, Some("test body".to_string()));
+        assert_eq!(request.headers.get("Content-Type"), Some(&"application/json".to_string()));
+    }
+
+    #[test]
+    fn test_response_builder() {
+        let response = Response::ok("success".to_string())
+            .with_header("X-Custom", "value");
+
+        assert_eq!(response.status_code, 200);
+        assert_eq!(response.body, "success");
+        assert_eq!(response.headers.get("X-Custom"), Some(&"value".to_string()));
+    }
+
+    #[test]
+    fn test_wildcard_routes() {
+        let mut handler = ApiHandler::new();
+
+        fn wildcard_handler(req: Request) -> Result<Response> {
+            Ok(Response::ok(format!("Wildcard: {}", req.path)))
+        }
+
+        handler.add_route("GET", "/api/*", wildcard_handler).unwrap();
+
+        let test_paths = vec!["/api/users", "/api/users/123", "/api/test"];
+
+        for path in test_paths {
+            let response = handler.handle_request("GET", path, None).unwrap();
+
+            match response {
+                ApiResponse::Success(resp) => {
+                    assert_eq!(resp.status_code, 200);
+                    assert!(resp.body.contains("Wildcard:"));
+                },
+                ApiResponse::Error(_) => panic!("Expected success for path: {}", path),
+            }
+        }
+    }
+}

package/.claude/skills/cfn-transparency-middleware/src/cache_manager.rs

@@ -0,0 +1,219 @@
+// Cache Manager Module - LRU Cache Implementation
+// Created with TDD approach
+
+use std::collections::{HashMap, VecDeque};
+
+#[derive(Debug, Clone)]
+pub struct CacheManager {
+    capacity: usize,
+    map: HashMap<String, String>,
+    order: VecDeque<String>,
+}
+
+impl CacheManager {
+    /// Creates a new LRU cache with the specified capacity
+    pub fn new(capacity: usize) -> Self {
+        Self {
+            capacity,
+            map: HashMap::new(),
+            order: VecDeque::new(),
+        }
+    }
+
+    /// Gets a value from the cache by key, moving it to the most recently used position
+    pub fn get(&mut self, key: &str) -> Option<&String> {
+        if self.map.contains_key(key) {
+            // Move key to the back (most recently used)
+            self.order.retain(|k| k != key);
+            self.order.push_back(key.to_string());
+            self.map.get(key)
+        } else {
+            None
+        }
+    }
+
+    /// Inserts a key-value pair into the cache, evicting the least recently used item if necessary
+    pub fn insert(&mut self, key: String, value: String) -> Option<String> {
+        // If capacity is 0, don't store anything
+        if self.capacity == 0 {
+            return None;
+        }
+
+        // If key already exists, update its value and move it to most recently used
+        if self.map.contains_key(&key) {
+            let old_value = self.map.get(&key).unwrap().clone();
+            self.order.retain(|k| k != &key);
+            self.order.push_back(key.clone());
+            self.map.insert(key, value);
+            return Some(old_value);
+        }
+
+        // If at capacity, remove least recently used item
+        if self.map.len() >= self.capacity {
+            if let Some(oldest_key) = self.order.pop_front() {
+                self.map.remove(&oldest_key);
+            }
+        }
+
+        // Insert new item
+        self.order.push_back(key.clone());
+        self.map.insert(key, value);
+        None
+    }
+
+    /// Clears all items from the cache
+    pub fn clear(&mut self) {
+        self.map.clear();
+        self.order.clear();
+    }
+
+    /// Returns the number of items in the cache
+    pub fn len(&self) -> usize {
+        self.map.len()
+    }
+
+    /// Returns true if the cache is empty
+    pub fn is_empty(&self) -> bool {
+        self.map.is_empty()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_new_cache() {
+        let cache = CacheManager::new(3);
+        assert_eq!(cache.len(), 0);
+        assert!(cache.is_empty());
+    }
+
+    #[test]
+    fn test_insert_and_get() {
+        let mut cache = CacheManager::new(3);
+
+        // Insert item
+        assert_eq!(cache.insert("key1".to_string(), "value1".to_string()), None);
+        assert_eq!(cache.len(), 1);
+        assert!(!cache.is_empty());
+
+        // Get item
+        assert_eq!(cache.get("key1"), Some(&"value1".to_string()));
+
+        // Get non-existent item
+        assert_eq!(cache.get("nonexistent"), None);
+    }
+
+    #[test]
+    fn test_insert_duplicate_key() {
+        let mut cache = CacheManager::new(3);
+
+        cache.insert("key1".to_string(), "value1".to_string());
+        let old_value = cache.insert("key1".to_string(), "value1_updated".to_string());
+
+        assert_eq!(old_value, Some("value1".to_string()));
+        assert_eq!(cache.get("key1"), Some(&"value1_updated".to_string()));
+        assert_eq!(cache.len(), 1);
+    }
+
+    #[test]
+    fn test_lru_eviction() {
+        let mut cache = CacheManager::new(2);
+
+        // Fill cache to capacity
+        cache.insert("key1".to_string(), "value1".to_string());
+        cache.insert("key2".to_string(), "value2".to_string());
+
+        // Access key1 to make it most recently used
+        cache.get("key1");
+
+        // Insert key3, should evict key2 (least recently used)
+        cache.insert("key3".to_string(), "value3".to_string());
+
+        assert_eq!(cache.get("key1"), Some(&"value1".to_string()));
+        assert_eq!(cache.get("key2"), None);
+        assert_eq!(cache.get("key3"), Some(&"value3".to_string()));
+        assert_eq!(cache.len(), 2);
+    }
+
+    #[test]
+    fn test_clear() {
+        let mut cache = CacheManager::new(3);
+
+        cache.insert("key1".to_string(), "value1".to_string());
+        cache.insert("key2".to_string(), "value2".to_string());
+
+        assert_eq!(cache.len(), 2);
+
+        cache.clear();
+
+        assert_eq!(cache.len(), 0);
+        assert!(cache.is_empty());
+        assert_eq!(cache.get("key1"), None);
+        assert_eq!(cache.get("key2"), None);
+    }
+
+    #[test]
+    fn test_update_moves_to_mru() {
+        let mut cache = CacheManager::new(3);
+
+        cache.insert("key1".to_string(), "value1".to_string());
+        cache.insert("key2".to_string(), "value2".to_string());
+        cache.insert("key3".to_string(), "value3".to_string());
+
+        // Update key1, should move it to most recently used
+        cache.insert("key1".to_string(), "value1_updated".to_string());
+
+        // Fill with new items to test eviction order
+        cache.insert("key4".to_string(), "value4".to_string());
+
+        // key2 should be evicted (it was least recently used)
+        assert_eq!(cache.get("key1"), Some(&"value1_updated".to_string()));
+        assert_eq!(cache.get("key2"), None);
+        assert_eq!(cache.get("key3"), Some(&"value3".to_string()));
+        assert_eq!(cache.get("key4"), Some(&"value4".to_string()));
+    }
+
+    #[test]
+    fn test_get_updates_order() {
+        let mut cache = CacheManager::new(2);
+
+        cache.insert("key1".to_string(), "value1".to_string());
+        cache.insert("key2".to_string(), "value2".to_string());
+
+        // Get key1, should move it to most recently used
+        cache.get("key1");
+
+        // Insert new item, should evict key2
+        cache.insert("key3".to_string(), "value3".to_string());
+
+        assert_eq!(cache.get("key1"), Some(&"value1".to_string()));
+        assert_eq!(cache.get("key2"), None);
+        assert_eq!(cache.get("key3"), Some(&"value3".to_string()));
+    }
+
+    #[test]
+    fn test_zero_capacity() {
+        let mut cache = CacheManager::new(0);
+
+        cache.insert("key1".to_string(), "value1".to_string());
+
+        assert_eq!(cache.len(), 0);
+        assert_eq!(cache.get("key1"), None);
+    }
+
+    #[test]
+    fn test_single_item_cache() {
+        let mut cache = CacheManager::new(1);
+
+        cache.insert("key1".to_string(), "value1".to_string());
+        assert_eq!(cache.get("key1"), Some(&"value1".to_string()));
+
+        cache.insert("key2".to_string(), "value2".to_string());
+
+        assert_eq!(cache.get("key1"), None);
+        assert_eq!(cache.get("key2"), Some(&"value2".to_string()));
+        assert_eq!(cache.len(), 1);
+    }
+}

package/.claude/skills/cfn-transparency-middleware/src/fix_regex.rs

@@ -0,0 +1,9 @@
+/// Redact pattern from content
+fn redact_pattern(&self, content: &str, pattern: &str) -> Result<String> {
+    use regex::Regex;
+
+    let regex = Regex::new(&format!(r"(?i){}[:\s=]+[^\s\n]+", pattern))
+        .with_context(|| format!("Invalid regex pattern: {}", pattern))?;
+
+    Ok(regex.replace_all(content, format!("{}: [REDACTED]", pattern)).to_string())
+}