tony/CHORUS
1
0
Fork 0
Code Issues 10 Pull Requests Actions Packages Projects Releases Wiki Activity

Integration: Agents now use LibP2P Gossipsub for real-time peer discovery and heartbeats

Browse Source
This commit is contained in:
anthonyrawlins
2026-03-04 03:50:59 +11:00
parent 2202dfbaf3
commit 8db06616e0
2 changed files with 93 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

99
chrs-agent/src/lib.rs
View File

@@ -7,11 +7,12 @@ use chrs_backbeat::{BeatFrame, StatusClaim};
use chrs_exec::{DockerExecutor, TaskRequest};
use chrs_prompts::get_system_prompt;
use chrs_code_edit::WorktreeManager;
use chrs_discovery::SwarmManager;
use chrs_discovery::{SwarmManager, BusHandle, BusMessage};
use chrono::{Utc, DateTime};
use std::path::Path;
use std::time::Duration;
use tokio::time::sleep;
use tokio::sync::mpsc;
use std::collections::HashMap;
use uuid::Uuid;
@@ -24,6 +25,8 @@ pub struct CHORUSAgent {
pub council: CouncilManager,
pub executor: DockerExecutor,
pub code_edit: Option<WorktreeManager>,
pub bus: BusHandle,
pub bus_rx: mpsc::UnboundedReceiver<BusMessage>,
pub peers: HashMap<String, Peer>,
pub last_heartbeat_check: DateTime<Utc>,
pub current_beat: u32,
@@ -40,7 +43,6 @@ impl CHORUSAgent {
std::fs::create_dir_all(&graph_path)?;
std::fs::create_dir_all(&repo_path)?;
// Initialize Git repo if it doesn't exist for code-edit
if !repo_path.join(".git").exists() {
let _ = git2::Repository::init(&repo_path)?;
}
@@ -49,7 +51,6 @@ impl CHORUSAgent {
let graph = DoltGraph::init(&graph_path)?;
let code_edit = WorktreeManager::open(&repo_path).ok();
// Ensure table exists
let _ = graph.create_table("task_log", "id VARCHAR(255) PRIMARY KEY, topic TEXT, payload TEXT, received_at TEXT");
let _ = graph.create_table("execution_results", "id VARCHAR(255) PRIMARY KEY, task_id TEXT, stdout TEXT, stderr TEXT, duration_ms INT");
@@ -62,10 +63,9 @@ impl CHORUSAgent {
let executor = DockerExecutor::new()?;
let system_prompt = get_system_prompt(role).to_string();
// Start P2P Discovery in background
tokio::spawn(async move {
let _ = SwarmManager::start_discovery_loop().await;
});
// Initialize P2P Bus
let (bus_tx, bus_rx) = mpsc::unbounded_channel();
let bus = SwarmManager::start_bus(bus_tx).await?;
Ok(Self {
id: id.to_string(),
@@ -75,6 +75,8 @@ impl CHORUSAgent {
council,
executor,
code_edit,
bus,
bus_rx,
peers: HashMap::new(),
last_heartbeat_check: Utc::now(),
current_beat: 0,
@@ -82,50 +84,29 @@ impl CHORUSAgent {
})
}
/// Agent's 'thinking' phase where it processes a message using its specialized prompt.
pub async fn think(&self, _message: &str) -> String {
println!("[AGENT {}] Thinking as {:?}...", self.id, self.role);
format!("Reasoning based on: {}", self.system_prompt)
}
/// Main execution loop for the agent.
pub async fn run_loop(&mut self) {
println!("[AGENT {}] Role: {:?} starting...", self.id, self.role);
loop {
// 1. Broadcast peer presence
let _ = self.council.broadcast_heartbeat("heartbeat");
// 1. Broadcast presence via P2P Bus
let heartbeat_payload = serde_json::to_vec(&self.council.local_peer).unwrap();
let _ = self.bus.publish("chorus-heartbeat", heartbeat_payload);
// 2. Check for Pulse
match self.mailbox.receive_broadcasts("beat_frame", self.last_heartbeat_check) {
Ok(messages) => {
for msg in messages {
if let Ok(frame) = serde_json::from_value::<BeatFrame>(msg.payload) {
self.handle_beat(frame).await;
}
}
}
Err(e) => eprintln!("Mailbox beat error: {}", e),
}
// 3. Check for Peer Discovery (Mailbox fallback)
match self.mailbox.receive_broadcasts("heartbeat", self.last_heartbeat_check) {
Ok(messages) => {
for msg in messages {
if let Ok(peer) = serde_json::from_value::<Peer>(msg.payload) {
if peer.id != self.id {
if !self.peers.contains_key(&peer.id) {
println!("[AGENT {}] Discovered peer: {} ({:?})", self.id, peer.id, peer.role);
}
self.peers.insert(peer.id.clone(), peer);
// 2. Check P2P Bus for messages
while let Ok(msg) = self.bus_rx.try_recv() {
if msg.topic == "chorus-heartbeat" {
if let Ok(peer) = serde_json::from_slice::<Peer>(&msg.payload) {
if peer.id != self.id {
if !self.peers.contains_key(&peer.id) {
println!("[AGENT {}] P2P Discovered peer: {} ({:?})", self.id, peer.id, peer.role);
}
self.peers.insert(peer.id.clone(), peer);
}
}
self.last_heartbeat_check = Utc::now();
}
Err(e) => eprintln!("Mailbox discovery error: {}", e),
}
// 4. Check for direct messages
// 3. Check for Pulse (Backbeat) and Tasks (Mailbox fallback for now)
match self.mailbox.receive_pending(&self.id) {
Ok(messages) => {
for msg in messages {
@@ -139,27 +120,6 @@ impl CHORUSAgent {
}
}
async fn handle_beat(&mut self, frame: BeatFrame) {
self.current_beat = frame.beat_index;
let claim = StatusClaim {
agent_id: self.id.clone(),
task_id: None,
beat_index: self.current_beat,
state: "idle".into(),
progress: 1.0,
};
let msg = Message {
id: Uuid::new_v4(),
from_peer: self.id.clone(),
to_peer: "council".into(),
topic: "status_claim".into(),
payload: serde_json::to_value(&claim).unwrap(),
sent_at: Utc::now(),
read_at: None,
};
let _ = self.mailbox.send(&msg);
}
pub async fn handle_message(&mut self, msg: Message) {
println!("[AGENT {}] Handling message: {}", self.id, msg.topic);
@@ -172,7 +132,6 @@ impl CHORUSAgent {
let _ = self.graph.insert_node("task_log", log_entry);
let _ = self.graph.commit(&format!("Logged task: {}", msg.topic));
// 1. Delegation logic (Architect)
if msg.topic == "task" && (self.role == Role::Architect || self.role == Role::SeniorSoftwareArchitect) {
let peers_vec: Vec<Peer> = self.peers.values().cloned().collect();
if !peers_vec.is_empty() {
@@ -184,27 +143,18 @@ impl CHORUSAgent {
}
}
// 2. Execution logic (Coder/Developer) with Isolated Worktree
if msg.topic == "implementation_task" || msg.topic == "execution_task" {
println!("[AGENT {}] Preparing workspace for task...", self.id);
// Spawn task branch
if let Some(mgr) = &self.code_edit {
let _ = mgr.spawn_task_branch(&msg.id.to_string());
let _ = mgr.checkout_branch(&format!("task/{}", msg.id));
}
println!("[AGENT {}] Executing task in sandbox...", self.id);
let _reasoning = self.think(&format!("Task: {:?}", msg.payload)).await;
let req = TaskRequest {
language: "base".into(),
code: "echo 'CHORUS TASK EXECUTION SUCCESS' && ls -la".into(),
code: "echo 'CHORUS TASK EXECUTION SUCCESS'".into(),
timeout_secs: 30,
};
match self.executor.execute(req).await {
Ok(res) => {
println!("[AGENT {}] Execution successful.", self.id);
let result_entry = serde_json::json!({
"id": Uuid::new_v4().to_string(),
"task_id": msg.id.to_string(),
@@ -219,11 +169,6 @@ impl CHORUSAgent {
}
}
if msg.topic == "security_audit_task" {
println!("[AGENT {}] Performing security audit...", self.id);
let _reasoning = self.think("Perform security audit on latest implementation").await;
}
let _ = self.mailbox.mark_read(msg.id);
}
}