chore: integrate syneidesis directly for now

Author: goedelsoup

Cargo.toml

@@ -56,7 +56,12 @@ members = [
     "crates/action-tools/syntax-validation-tool",
     "crates/action-tools/type-checking-tool",
     "crates/action-tools/test-coverage-tool",
-    "crates/action-tools/security-scanning-tool"
+    "crates/action-tools/security-scanning-tool",
+    "crates/syneidesis/coordination",
+    "crates/syneidesis/grpc",
+    "crates/syneidesis/config",
+    "crates/syneidesis/core",
+    "crates/syneidesis/agent"
 ]
 
 [workspace.package]
@@ -68,6 +73,7 @@ repository = "https://github.com/fugue-ai/rhema"
 homepage = "https://github.com/fugue-ai/rhema"
 documentation = "https://docs.rs/rhema"
 readme = "README.md"
+description = "Rhema AI Agent Framework"
 keywords = ["git", "ai", "context", "yaml", "protocol", "agent", "cli"]
 categories = ["command-line-utilities", "development-tools", "configuration"]
 
@@ -103,7 +109,9 @@ async-trait = "0.1"
 tracing = "0.1"
 
 # Syneidesis Coordination Library
-syneidesis-coordination = { path = "../syneidesis/crates/coordination" }
+syneidesis-coordination = { path = "crates/syneidesis/coordination" }
+syneidesis-grpc = { path = "crates/syneidesis/grpc" }
+syneidesis-config = { path = "crates/syneidesis/config" }
 
 # gRPC and networking dependencies
 tokio-stream = "0.1"
@@ -165,6 +173,12 @@ trycmd = "0.15"
 env_logger = "0.10"
 rand = "0.8"
 
+# Additional dependencies for syneidesis
+parking_lot = "0.12"
+tokio-util = "0.7"
+tokio-tungstenite = "0.20"
+prost = "0.12"
+
 [dev-dependencies]
 tempfile = "3.8"
 assert_fs = "1.1"

apps/rhema/src/lib.rs

@@ -315,8 +315,12 @@ impl ConfigManager {
 
     pub fn global_config_mut(&mut self) -> std::sync::MutexGuard<'static, GlobalConfig> {
         // TODO: Implement actual global config loading
-        static GLOBAL_CONFIG: std::sync::OnceLock<std::sync::Mutex<GlobalConfig>> = std::sync::OnceLock::new();
-        GLOBAL_CONFIG.get_or_init(|| std::sync::Mutex::new(GlobalConfig::new())).lock().unwrap()
+        static GLOBAL_CONFIG: std::sync::OnceLock<std::sync::Mutex<GlobalConfig>> =
+            std::sync::OnceLock::new();
+        GLOBAL_CONFIG
+            .get_or_init(|| std::sync::Mutex::new(GlobalConfig::new()))
+            .lock()
+            .unwrap()
     }
 
     pub fn load_repository_config(
@@ -353,17 +357,23 @@ impl ConfigManager {
         })
     }
 
-    pub fn backup_mut(&mut self) -> std::sync::MutexGuard<'static, rhema_config::backup::BackupManager> {
+    pub fn backup_mut(
+        &mut self,
+    ) -> std::sync::MutexGuard<'static, rhema_config::backup::BackupManager> {
         // TODO: Implement actual backup
-        static BACKUP: std::sync::OnceLock<std::sync::Mutex<rhema_config::backup::BackupManager>> = std::sync::OnceLock::new();
-        BACKUP.get_or_init(|| {
-            let global_config = self.global_config();
-            std::sync::Mutex::new(
-                rhema_config::backup::BackupManager::new(global_config).unwrap_or_else(|_| {
-                    rhema_config::backup::BackupManager::new(global_config).unwrap()
-                })
-            )
-        }).lock().unwrap()
+        static BACKUP: std::sync::OnceLock<std::sync::Mutex<rhema_config::backup::BackupManager>> =
+            std::sync::OnceLock::new();
+        BACKUP
+            .get_or_init(|| {
+                let global_config = self.global_config();
+                std::sync::Mutex::new(
+                    rhema_config::backup::BackupManager::new(global_config).unwrap_or_else(|_| {
+                        rhema_config::backup::BackupManager::new(global_config).unwrap()
+                    }),
+                )
+            })
+            .lock()
+            .unwrap()
     }
 
     pub fn migration(&self) -> &rhema_config::migration::MigrationManager {

apps/rhema/src/main.rs

@@ -1,7 +1,6 @@
 use clap::{Parser, Subcommand};
 use rhema_api::{Rhema, RhemaResult};
 
-
 #[derive(Parser)]
 #[command(author, version, about, long_about = None)]
 struct Cli {
@@ -16,88 +15,87 @@ enum Commands {
         /// Scope type (e.g., service, library, application)
         #[arg(long)]
         scope_type: Option<String>,
-        
+
         /// Scope name
         #[arg(long)]
         scope_name: Option<String>,
-        
+
         /// Auto-configure based on repository analysis
         #[arg(long)]
         auto_config: bool,
     },
-    
+
     /// List all scopes in the repository
     Scopes,
-    
+
     /// Show information about a specific scope
     Scope {
         /// Path to the scope
         path: Option<String>,
     },
-    
+
     /// Show the scope tree
     Tree,
-    
+
     /// Execute a CQL query
     Query {
         /// The CQL query to execute
         query: String,
-        
+
         /// Output format (json, yaml, table)
         #[arg(short, long, default_value = "table")]
         format: String,
-        
+
         /// Include provenance information
         #[arg(long)]
         provenance: bool,
-        
+
         /// Include field provenance
         #[arg(long)]
         field_provenance: bool,
-        
+
         /// Include statistics
         #[arg(long)]
         stats: bool,
     },
-    
+
     /// Search for content in the repository
     Search {
         /// Search term
         term: String,
-        
+
         /// Search in specific file
         #[arg(short, long)]
         in_file: Option<String>,
-        
+
         /// Use regex search
         #[arg(long)]
         regex: bool,
     },
-    
+
     /// Validate the repository
     Validate {
         /// Validate recursively
         #[arg(long)]
         recursive: bool,
-        
+
         /// Use JSON schema validation
         #[arg(long)]
         json_schema: bool,
-        
+
         /// Migrate schemas if needed
         #[arg(long)]
         migrate: bool,
     },
-    
+
     /// Show health information
     Health {
         /// Scope to check health for
         scope: Option<String>,
     },
-    
+
     /// Show statistics
     Stats,
-    
     // /// Manage coordination between agents
     // Coordination {
     //     #[command(subcommand)]
@@ -108,11 +106,15 @@ enum Commands {
 #[tokio::main]
 async fn main() -> RhemaResult<()> {
     let cli = Cli::parse();
-    
+
     let rhema = Rhema::new()?;
-    
+
     match &cli.command {
-        Some(Commands::Init { scope_type, scope_name, auto_config }) => {
+        Some(Commands::Init {
+            scope_type,
+            scope_name,
+            auto_config,
+        }) => {
             println!("Initializing new Rhema repository...");
             rhema_api::init::run(
                 &rhema,
@@ -121,7 +123,7 @@ async fn main() -> RhemaResult<()> {
                 *auto_config,
             )
         }
-        
+
         Some(Commands::Scopes) => {
             println!("Discovering scopes...");
             let scopes = rhema.discover_scopes()?;
@@ -130,7 +132,7 @@ async fn main() -> RhemaResult<()> {
             }
             Ok(())
         }
-        
+
         Some(Commands::Scope { path }) => {
             if let Some(scope_path) = path {
                 println!("Showing scope: {}", scope_path);
@@ -142,7 +144,7 @@ async fn main() -> RhemaResult<()> {
             }
             Ok(())
         }
-        
+
         Some(Commands::Tree) => {
             println!("Showing scope tree...");
             let scopes = rhema.discover_scopes()?;
@@ -151,10 +153,16 @@ async fn main() -> RhemaResult<()> {
             }
             Ok(())
         }
-        
-        Some(Commands::Query { query, format, provenance, field_provenance, stats }) => {
+
+        Some(Commands::Query {
+            query,
+            format,
+            provenance,
+            field_provenance,
+            stats,
+        }) => {
             println!("Executing query: {}", query);
-            
+
             if *field_provenance {
                 let (result, _) = rhema.query_with_provenance(query)?;
                 println!("Result: {:?}", result);
@@ -175,24 +183,32 @@ async fn main() -> RhemaResult<()> {
             }
             Ok(())
         }
-        
-        Some(Commands::Search { term, in_file, regex }) => {
+
+        Some(Commands::Search {
+            term,
+            in_file,
+            regex,
+        }) => {
             println!("Searching for: {}", term);
             if let Some(file) = in_file {
                 println!("In file: {}", file);
             }
             if *regex {
                 println!("Using regex search");
             }
-            
+
             let results = rhema.search_regex(term, in_file.as_deref())?;
             for result in results {
                 println!("Found: {:?}", result);
             }
             Ok(())
         }
-        
-        Some(Commands::Validate { recursive, json_schema, migrate }) => {
+
+        Some(Commands::Validate {
+            recursive,
+            json_schema,
+            migrate,
+        }) => {
             println!("Validating repository...");
             if *recursive {
                 println!("Validating recursively");
@@ -206,7 +222,7 @@ async fn main() -> RhemaResult<()> {
             println!("Validation completed successfully!");
             Ok(())
         }
-        
+
         Some(Commands::Health { scope }) => {
             println!("Checking health...");
             if let Some(scope_name) = scope {
@@ -215,17 +231,17 @@ async fn main() -> RhemaResult<()> {
             println!("Health check completed successfully!");
             Ok(())
         }
-        
+
         Some(Commands::Stats) => {
             println!("Showing statistics...");
             println!("Statistics feature not yet implemented");
             Ok(())
         }
-        
+
         // Some(Commands::Coordination { subcommand }) => {
         //     println!("Executing coordination command...");
         //     let manager = CoordinationManager::new();
-        //     
+        //
         //     match subcommand {
         //         CoordinationSubcommands::Agent { subcommand } => {
         //             manager.execute_agent_command(subcommand).await
@@ -238,7 +254,6 @@ async fn main() -> RhemaResult<()> {
         //         }
         //     }
         // }
-        
         None => {
             println!("Welcome to Rhema CLI!");
             println!("Use --help to see available commands");