299 lines
11 KiB
Rust
299 lines
11 KiB
Rust
//! Mandatory explore phase — spawns ≥3 parallel subagents to discover
|
|
//! codebase context before every agent turn, visible in the TUI workflow tab.
|
|
//!
|
|
//! # Flow
|
|
//!
|
|
//! `ExploreServiceImpl::explore()` →
|
|
//!
|
|
//! 1. Push `WorkflowAgentUpdate { Pending }` for each agent onto the turn-event
|
|
//! queue so the TUI workflow tab shows all 3.
|
|
//! 2. Spawn **Code Structure** subagent (thread + tokio runtime).
|
|
//! 3. Spawn **Symbol Index** subagent (thread + tokio runtime).
|
|
//! 4. Spawn **Semantic Context** subagent (thread + tokio runtime).
|
|
//! 5. Join all handles via `spawn_blocking`.
|
|
//! 6. Push `Completed` / `Failed` events for each agent.
|
|
//! 7. Consolidate findings into a system message → return.
|
|
|
|
use crate::subagent::context::SubagentContext;
|
|
use crate::subagent::division::AccessTier;
|
|
use crate::subagent::engine::run_agent;
|
|
use crate::tools::ToolCtx;
|
|
use anyhow::{Context, Result};
|
|
use std::collections::VecDeque;
|
|
use std::future::Future;
|
|
use std::pin::Pin;
|
|
use std::sync::{Arc, Mutex};
|
|
use std::thread;
|
|
use tracing::{info, warn};
|
|
use zesdex_application::agent::{ExploreOutput, ExploreService};
|
|
use zesdex_domain::agent::{AgentStatus, TurnEvent};
|
|
|
|
/// Number of parallel explore subagents.
|
|
const EXPLORE_AGENT_COUNT: usize = 3;
|
|
|
|
/// IDs for each explore agent (shown in the workflow tab).
|
|
const EXPLORE_IDS: [&str; 3] = ["explore-structure", "explore-symbols", "explore-context"];
|
|
|
|
/// Display names for the TUI workflow tab.
|
|
const EXPLORE_LABELS: [&str; 3] = [
|
|
"📁 Code Structure",
|
|
"🔣 Symbol Index",
|
|
"🔍 Semantic Context",
|
|
];
|
|
|
|
/// Directives for each explore subagent.
|
|
const EXPLORE_DIRECTIVES: [&str; 3] = [
|
|
// Agent 0: Code Structure
|
|
"You are a codebase structure explorer.\n\
|
|
1. List all top-level directories and files in the workspace root.\n\
|
|
2. Read Cargo.toml, package.json, or pyproject.toml at the root.\n\
|
|
3. List the apps/ or src/ directory contents.\n\
|
|
4. Identify main entry points (main.rs, main.py, index.ts, etc.).\n\
|
|
5. Count files by extension type.\n\
|
|
Use the ls_dir, read, grep, and glob tools. Be concise.",
|
|
|
|
// Agent 1: Symbol Index
|
|
"You are a symbol index explorer.\n\
|
|
1. Call the 'rebuild_index' tool to rebuild the symbol index.\n\
|
|
2. Call the 'list_symbols' tool with max_results: 100.\n\
|
|
3. Identify public APIs, entry points, and key types.\n\
|
|
4. Group symbols by language and kind.\n\
|
|
Be concise. Report what symbols exist and where they live.",
|
|
|
|
// Agent 2: Semantic Context
|
|
"You are a semantic context explorer.\n\
|
|
1. Call the 'rebuild_index' tool to ensure the index is fresh.\n\
|
|
2. Search for symbols related to the user's query using semantic_search.\n\
|
|
3. Search for config files, env variables, and settings.\n\
|
|
4. Search for test files and test patterns.\n\
|
|
Be concise. Report relevant code areas for the task.\n\
|
|
Use the semantic_search, grep, glob, and read tools.",
|
|
];
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Credentials
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// LLM credentials for explore subagents.
|
|
pub struct Credentials {
|
|
pub base_url: String,
|
|
pub api_key: String,
|
|
pub model: String,
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ExploreServiceImpl — implements the application-layer trait
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Concrete [`ExploreService`] that the turn service calls.
|
|
///
|
|
/// Owns a shared `ToolCtx` and LLM credentials. Each call to `explore()`
|
|
/// spawns 3 subagents in parallel with TUI workflow-tab visibility.
|
|
pub struct ExploreServiceImpl {
|
|
tool_ctx: ToolCtx,
|
|
credentials: Credentials,
|
|
}
|
|
|
|
impl ExploreServiceImpl {
|
|
pub fn new(tool_ctx: ToolCtx, credentials: Credentials) -> Self {
|
|
ExploreServiceImpl {
|
|
tool_ctx,
|
|
credentials,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ExploreService for ExploreServiceImpl {
|
|
fn explore<'a>(
|
|
&'a self,
|
|
query: &'a str,
|
|
workspace_root: &'a str,
|
|
turn_events: &'a Arc<Mutex<VecDeque<TurnEvent>>>,
|
|
) -> Pin<Box<dyn Future<Output = Result<ExploreOutput>> + Send + 'a>> {
|
|
Box::pin(async move {
|
|
let context = run_explore_phase(
|
|
query,
|
|
workspace_root,
|
|
&self.tool_ctx,
|
|
&self.credentials,
|
|
turn_events,
|
|
)
|
|
.await?;
|
|
|
|
Ok(ExploreOutput {
|
|
context_messages: vec![context],
|
|
summary: format!("{EXPLORE_AGENT_COUNT} explore agents dispatched"),
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Helpers for pushing workflow events
|
|
// ---------------------------------------------------------------------------
|
|
|
|
fn push_event(events: &Arc<Mutex<VecDeque<TurnEvent>>>, event: TurnEvent) {
|
|
if let Ok(mut q) = events.lock() {
|
|
q.push_back(event);
|
|
}
|
|
}
|
|
|
|
fn emit_pending(events: &Arc<Mutex<VecDeque<TurnEvent>>>, agent_id: &str, display: &str) {
|
|
push_event(
|
|
events,
|
|
TurnEvent::WorkflowAgentUpdate {
|
|
agent_id: agent_id.to_string(),
|
|
agent_name: display.to_string(),
|
|
status: AgentStatus::Pending,
|
|
},
|
|
);
|
|
}
|
|
|
|
fn emit_running(events: &Arc<Mutex<VecDeque<TurnEvent>>>, agent_id: &str, display: &str) {
|
|
push_event(
|
|
events,
|
|
TurnEvent::WorkflowAgentUpdate {
|
|
agent_id: agent_id.to_string(),
|
|
agent_name: display.to_string(),
|
|
status: AgentStatus::Running,
|
|
},
|
|
);
|
|
}
|
|
|
|
fn emit_completed(events: &Arc<Mutex<VecDeque<TurnEvent>>>, agent_id: &str, display: &str) {
|
|
push_event(
|
|
events,
|
|
TurnEvent::WorkflowAgentUpdate {
|
|
agent_id: agent_id.to_string(),
|
|
agent_name: display.to_string(),
|
|
status: AgentStatus::Completed,
|
|
},
|
|
);
|
|
}
|
|
|
|
fn emit_failed(events: &Arc<Mutex<VecDeque<TurnEvent>>>, agent_id: &str, display: &str, msg: &str) {
|
|
push_event(
|
|
events,
|
|
TurnEvent::WorkflowAgentUpdate {
|
|
agent_id: agent_id.to_string(),
|
|
agent_name: display.to_string(),
|
|
status: AgentStatus::Failed(msg.to_string()),
|
|
},
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Core orchestration
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Spawn `EXPLORE_AGENT_COUNT` subagents in parallel, emit workflow events
|
|
/// for the TUI tab, join, and consolidate.
|
|
async fn run_explore_phase(
|
|
query: &str,
|
|
workspace_root: &str,
|
|
tool_ctx: &ToolCtx,
|
|
credentials: &Credentials,
|
|
turn_events: &Arc<Mutex<VecDeque<TurnEvent>>>,
|
|
) -> Result<String> {
|
|
// ── 1. Emit Pending for all agents (appears instantly in workflow tab) ─
|
|
for i in 0..EXPLORE_AGENT_COUNT {
|
|
emit_pending(turn_events, EXPLORE_IDS[i], EXPLORE_LABELS[i]);
|
|
}
|
|
|
|
// ── 2. Prepare directives ───────────────────────────────────────────
|
|
let mut directives: Vec<String> = Vec::with_capacity(EXPLORE_AGENT_COUNT);
|
|
for i in 0..EXPLORE_AGENT_COUNT {
|
|
let mut d = EXPLORE_DIRECTIVES[i].to_string();
|
|
if i == 2 {
|
|
d.push_str(&format!("\n\nThe user's current query is: \"{query}\""));
|
|
}
|
|
d.push_str(&format!("\n\nWorkspace root: {workspace_root}"));
|
|
directives.push(d);
|
|
}
|
|
|
|
// ── 3. Spawn all agents on threads ──────────────────────────────────
|
|
let mut handles: Vec<(usize, thread::JoinHandle<Result<String>>)> =
|
|
Vec::with_capacity(EXPLORE_AGENT_COUNT);
|
|
|
|
for i in 0..EXPLORE_AGENT_COUNT {
|
|
emit_running(turn_events, EXPLORE_IDS[i], EXPLORE_LABELS[i]);
|
|
|
|
let ctx = SubagentContext::new(
|
|
directives[i].clone(),
|
|
tool_ctx.clone(),
|
|
"read".to_string(),
|
|
credentials.base_url.clone(),
|
|
credentials.api_key.clone(),
|
|
credentials.model.clone(),
|
|
);
|
|
|
|
let directive = directives[i].clone();
|
|
let tc = tool_ctx.clone();
|
|
|
|
let handle = thread::spawn(move || {
|
|
let rt = tokio::runtime::Runtime::new()
|
|
.context("create explore subagent tokio runtime")?;
|
|
rt.block_on(run_agent(ctx, &directive, AccessTier::Read, tc))
|
|
});
|
|
|
|
handles.push((i, handle));
|
|
}
|
|
|
|
// ── 4. Join handles via spawn_blocking ──────────────────────────────
|
|
let turn_events_clone = Arc::clone(turn_events);
|
|
let results: Vec<(usize, String, bool)> = tokio::task::spawn_blocking(move || {
|
|
let mut out = Vec::with_capacity(EXPLORE_AGENT_COUNT);
|
|
for (i, handle) in handles {
|
|
let entry = match handle.join() {
|
|
Ok(Ok(output)) => {
|
|
info!(agent = i, "explore subagent completed");
|
|
emit_completed(&turn_events_clone, EXPLORE_IDS[i], EXPLORE_LABELS[i]);
|
|
(i, output, true)
|
|
}
|
|
Ok(Err(e)) => {
|
|
warn!(agent = i, error = %e, "explore subagent failed");
|
|
emit_failed(&turn_events_clone, EXPLORE_IDS[i], EXPLORE_LABELS[i], &e.to_string());
|
|
(i, format!("Error: {e}"), false)
|
|
}
|
|
Err(e) => {
|
|
warn!(agent = i, error = ?e, "explore subagent panicked");
|
|
emit_failed(&turn_events_clone, EXPLORE_IDS[i], EXPLORE_LABELS[i], "thread panicked");
|
|
(i, format!("Thread panic: {e:?}"), false)
|
|
}
|
|
};
|
|
out.push(entry);
|
|
}
|
|
out
|
|
})
|
|
.await
|
|
.context("explore join task panicked")?;
|
|
|
|
// ── 5. Build consolidated context ───────────────────────────────────
|
|
Ok(build_explore_context(&results))
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Consolidation
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Format explore results as a system-level context message.
|
|
fn build_explore_context(results: &[(usize, String, bool)]) -> String {
|
|
let success_count = results.iter().filter(|r| r.2).count();
|
|
let total = results.len();
|
|
|
|
let mut msg = format!(
|
|
"[Explore Phase — {success_count}/{total} agents succeeded]\n\n"
|
|
);
|
|
|
|
for (i, output, success) in results {
|
|
let label = EXPLORE_LABELS.get(*i).unwrap_or(&"❓ Unknown");
|
|
if *success {
|
|
msg.push_str(&format!("=== {label} ===\n{output}\n\n"));
|
|
} else {
|
|
msg.push_str(&format!("=== {label} (FAILED) ===\n{output}\n\n"));
|
|
}
|
|
}
|
|
|
|
msg
|
|
}
|