Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

vendor/ruvector/examples/edge/src/lib.rs

@@ -0,0 +1,193 @@
+//! # RuVector Edge - Distributed AI Swarm Communication
+//!
+//! Edge AI swarm communication using `ruv-swarm-transport` with RuVector intelligence.
+//!
+//! ## Features
+//!
+//! - **WebSocket Transport**: Remote swarm communication
+//! - **SharedMemory Transport**: High-performance local IPC
+//! - **WASM Support**: Run in browser/edge environments
+//! - **Intelligence Sync**: Distributed Q-learning across agents
+//! - **Memory Sharing**: Shared vector memory for RAG
+//! - **Tensor Compression**: Efficient pattern transfer
+//!
+//! ## Quick Start
+//!
+//! ```rust,no_run
+//! use ruvector_edge::{SwarmAgent, SwarmConfig, Transport};
+//!
+//! #[tokio::main]
+//! async fn main() {
+//!     let config = SwarmConfig::default()
+//!         .with_transport(Transport::WebSocket)
+//!         .with_agent_id("agent-001");
+//!
+//!     let mut agent = SwarmAgent::new(config).await.unwrap();
+//!     agent.join_swarm("ws://coordinator:8080").await.unwrap();
+//!
+//!     // Sync learning patterns
+//!     agent.sync_patterns().await.unwrap();
+//! }
+//! ```
+
+// Native-only modules (require tokio)
+#[cfg(feature = "native")]
+pub mod transport;
+#[cfg(feature = "native")]
+pub mod agent;
+#[cfg(feature = "native")]
+pub mod gun;
+
+// Cross-platform modules
+pub mod intelligence;
+pub mod memory;
+pub mod compression;
+pub mod protocol;
+pub mod p2p;
+pub mod plaid;
+
+// WASM bindings
+#[cfg(feature = "wasm")]
+pub mod wasm;
+
+// Native re-exports
+#[cfg(feature = "native")]
+pub use agent::{SwarmAgent, AgentRole};
+#[cfg(feature = "native")]
+pub use transport::{Transport, TransportConfig};
+#[cfg(feature = "native")]
+pub use gun::{GunSync, GunSwarmBuilder, GunSwarmConfig, GunSwarmStats};
+
+// Cross-platform re-exports
+pub use intelligence::{IntelligenceSync, LearningState, Pattern};
+pub use memory::{SharedMemory, VectorMemory};
+pub use compression::{TensorCodec, CompressionLevel};
+pub use protocol::{SwarmMessage, MessageType};
+pub use p2p::{IdentityManager, CryptoV2, RelayManager, ArtifactStore};
+pub use plaid::{
+    Transaction, SpendingPattern, CategoryPrediction,
+    AnomalyResult, BudgetRecommendation, FinancialLearningState,
+};
+#[cfg(feature = "native")]
+pub use p2p::{P2PSwarmV2, SwarmStatus};
+
+// WASM re-exports
+#[cfg(feature = "wasm")]
+pub use wasm::*;
+
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+/// Swarm configuration (native only - uses Transport)
+#[cfg(feature = "native")]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SwarmConfig {
+    pub agent_id: String,
+    pub agent_role: AgentRole,
+    pub transport: Transport,
+    pub coordinator_url: Option<String>,
+    pub sync_interval_ms: u64,
+    pub compression_level: CompressionLevel,
+    pub max_peers: usize,
+    pub enable_learning: bool,
+    pub enable_memory_sync: bool,
+}
+
+#[cfg(feature = "native")]
+impl Default for SwarmConfig {
+    fn default() -> Self {
+        Self {
+            agent_id: Uuid::new_v4().to_string(),
+            agent_role: AgentRole::Worker,
+            transport: Transport::WebSocket,
+            coordinator_url: None,
+            sync_interval_ms: 1000,
+            compression_level: CompressionLevel::Fast,
+            max_peers: 100,
+            enable_learning: true,
+            enable_memory_sync: true,
+        }
+    }
+}
+
+#[cfg(feature = "native")]
+impl SwarmConfig {
+    pub fn with_transport(mut self, transport: Transport) -> Self {
+        self.transport = transport;
+        self
+    }
+
+    pub fn with_agent_id(mut self, id: impl Into<String>) -> Self {
+        self.agent_id = id.into();
+        self
+    }
+
+    pub fn with_role(mut self, role: AgentRole) -> Self {
+        self.agent_role = role;
+        self
+    }
+
+    pub fn with_coordinator(mut self, url: impl Into<String>) -> Self {
+        self.coordinator_url = Some(url.into());
+        self
+    }
+}
+
+/// Error types for edge swarm operations
+#[derive(Debug, thiserror::Error)]
+pub enum SwarmError {
+    #[error("Transport error: {0}")]
+    Transport(String),
+
+    #[error("Connection failed: {0}")]
+    Connection(String),
+
+    #[error("Serialization error: {0}")]
+    Serialization(String),
+
+    #[error("Compression error: {0}")]
+    Compression(String),
+
+    #[error("Sync error: {0}")]
+    Sync(String),
+
+    #[error("Agent not found: {0}")]
+    AgentNotFound(String),
+
+    #[error("Configuration error: {0}")]
+    Config(String),
+}
+
+pub type Result<T> = std::result::Result<T, SwarmError>;
+
+/// Prelude for convenient imports
+pub mod prelude {
+    pub use crate::{
+        SwarmError, Result, MessageType,
+        IntelligenceSync, SharedMemory,
+        CompressionLevel,
+    };
+
+    #[cfg(feature = "native")]
+    pub use crate::{
+        SwarmAgent, SwarmConfig,
+        Transport, AgentRole,
+    };
+}
+
+#[cfg(all(test, feature = "native"))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_config_builder() {
+        let config = SwarmConfig::default()
+            .with_agent_id("test-agent")
+            .with_transport(Transport::SharedMemory)
+            .with_role(AgentRole::Coordinator);
+
+        assert_eq!(config.agent_id, "test-agent");
+        assert!(matches!(config.transport, Transport::SharedMemory));
+        assert!(matches!(config.agent_role, AgentRole::Coordinator));
+    }
+}