417 lines
14 KiB
Rust
417 lines
14 KiB
Rust
use crate::*;
|
|
|
|
use api::{
|
|
detect_provider_kind, model_family_identity_for, resolve_startup_auth_source, AnthropicClient,
|
|
AuthSource, ContentBlockDelta, InputContentBlock, InputMessage, MessageRequest,
|
|
MessageResponse, OutputContentBlock, PromptCache, ProviderClient as ApiProviderClient,
|
|
ProviderKind, StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition,
|
|
ToolResultContentBlock,
|
|
};
|
|
use commands::{
|
|
classify_skills_slash_command, handle_agents_slash_command, handle_agents_slash_command_json,
|
|
handle_mcp_slash_command, handle_mcp_slash_command_json, handle_plugins_slash_command,
|
|
handle_skills_slash_command, handle_skills_slash_command_json, render_slash_command_help,
|
|
render_slash_command_help_filtered, resolve_skill_invocation, resume_supported_slash_commands,
|
|
slash_command_specs, validate_slash_command_input, PluginsCommandResult, SkillSlashDispatch,
|
|
SlashCommand,
|
|
};
|
|
use init::initialize_repo;
|
|
use log::debug;
|
|
use plugins::{PluginHooks, PluginManager, PluginManagerConfig, PluginRegistry};
|
|
use render::{MarkdownStreamState, Spinner, TerminalRenderer};
|
|
use runtime::{
|
|
check_base_commit, format_stale_base_warning, format_usd, load_oauth_credentials,
|
|
load_system_prompt, load_system_prompt_with_context, pricing_for_model, resolve_expected_base,
|
|
resolve_sandbox_status, ApiClient, ApiRequest, AssistantEvent, BaseCommitState,
|
|
CompactionConfig, ConfigFileReport, ConfigLoader, ConfigSource, ContentBlock, ContextFile,
|
|
ConversationMessage, ConversationRuntime, McpConfigCollection, McpInvalidServerConfig,
|
|
McpServer, McpServerManager, McpServerSpec, McpTool, MessageRole, ModelPricing, PermissionMode,
|
|
PermissionPolicy, ProjectContext, PromptCacheEvent, ResolvedPermissionMode, RuntimeError,
|
|
RuntimeInvalidHookConfig, Session, TokenUsage, ToolError, ToolExecutor, UsageTracker,
|
|
};
|
|
use serde::Deserialize;
|
|
use serde_json::{json, Map, Value};
|
|
use std::collections::BTreeSet;
|
|
use std::env;
|
|
use std::fs;
|
|
use std::io::{self, IsTerminal, Read, Write};
|
|
use std::net::TcpListener;
|
|
use std::ops::{Deref, DerefMut};
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::Command;
|
|
use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender};
|
|
use std::sync::{Arc, Mutex, OnceLock};
|
|
use std::thread::{self, JoinHandle};
|
|
use std::time::{Duration, Instant, UNIX_EPOCH};
|
|
use tools::{
|
|
canonical_allowed_tool_name, execute_tool, mvp_tool_specs, GlobalToolRegistry,
|
|
RuntimeToolDefinition, ToolSearchOutput,
|
|
};
|
|
|
|
pub(crate) struct HookAbortMonitor {
|
|
pub(crate) stop_tx: Option<Sender<()>>,
|
|
pub(crate) join_handle: Option<JoinHandle<()>>,
|
|
}
|
|
|
|
impl HookAbortMonitor {
|
|
pub(crate) fn spawn(abort_signal: runtime::HookAbortSignal) -> Self {
|
|
Self::spawn_with_waiter(abort_signal, move |stop_rx, abort_signal| {
|
|
let Ok(runtime) = tokio::runtime::Builder::new_current_thread()
|
|
.enable_all()
|
|
.build()
|
|
else {
|
|
return;
|
|
};
|
|
|
|
runtime.block_on(async move {
|
|
let wait_for_stop = tokio::task::spawn_blocking(move || {
|
|
let _ = stop_rx.recv();
|
|
});
|
|
|
|
tokio::select! {
|
|
result = tokio::signal::ctrl_c() => {
|
|
if result.is_ok() {
|
|
abort_signal.abort();
|
|
}
|
|
}
|
|
_ = wait_for_stop => {}
|
|
}
|
|
});
|
|
})
|
|
}
|
|
|
|
pub(crate) fn spawn_with_waiter<F>(
|
|
abort_signal: runtime::HookAbortSignal,
|
|
wait_for_interrupt: F,
|
|
) -> Self
|
|
where
|
|
F: FnOnce(Receiver<()>, runtime::HookAbortSignal) + Send + 'static,
|
|
{
|
|
let (stop_tx, stop_rx) = mpsc::channel();
|
|
let join_handle = thread::spawn(move || wait_for_interrupt(stop_rx, abort_signal));
|
|
|
|
Self {
|
|
stop_tx: Some(stop_tx),
|
|
join_handle: Some(join_handle),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn stop(mut self) {
|
|
if let Some(stop_tx) = self.stop_tx.take() {
|
|
let _ = stop_tx.send(());
|
|
}
|
|
if let Some(join_handle) = self.join_handle.take() {
|
|
let _ = join_handle.join();
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub(crate) struct InternalPromptProgressState {
|
|
pub(crate) command_label: &'static str,
|
|
pub(crate) task_label: String,
|
|
pub(crate) step: usize,
|
|
pub(crate) phase: String,
|
|
pub(crate) detail: Option<String>,
|
|
pub(crate) saw_final_text: bool,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub(crate) enum InternalPromptProgressEvent {
|
|
Started,
|
|
Update,
|
|
Heartbeat,
|
|
Complete,
|
|
Failed,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) struct InternalPromptProgressShared {
|
|
pub(crate) state: Mutex<InternalPromptProgressState>,
|
|
pub(crate) output_lock: Mutex<()>,
|
|
pub(crate) started_at: Instant,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub(crate) struct InternalPromptProgressReporter {
|
|
pub(crate) shared: Arc<InternalPromptProgressShared>,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(crate) struct InternalPromptProgressRun {
|
|
pub(crate) reporter: InternalPromptProgressReporter,
|
|
pub(crate) heartbeat_stop: Option<mpsc::Sender<()>>,
|
|
pub(crate) heartbeat_handle: Option<thread::JoinHandle<()>>,
|
|
}
|
|
|
|
impl InternalPromptProgressReporter {
|
|
pub(crate) fn ultraplan(task: &str) -> Self {
|
|
Self {
|
|
shared: Arc::new(InternalPromptProgressShared {
|
|
state: Mutex::new(InternalPromptProgressState {
|
|
command_label: "Ultraplan",
|
|
task_label: task.to_string(),
|
|
step: 0,
|
|
phase: "planning started".to_string(),
|
|
detail: Some(format!("task: {task}")),
|
|
saw_final_text: false,
|
|
}),
|
|
output_lock: Mutex::new(()),
|
|
started_at: Instant::now(),
|
|
}),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn emit(&self, event: InternalPromptProgressEvent, error: Option<&str>) {
|
|
let snapshot = self.snapshot();
|
|
let line = format_internal_prompt_progress_line(event, &snapshot, self.elapsed(), error);
|
|
self.write_line(&line);
|
|
}
|
|
|
|
pub(crate) fn mark_model_phase(&self) {
|
|
let snapshot = {
|
|
let mut state = self
|
|
.shared
|
|
.state
|
|
.lock()
|
|
.expect("internal prompt progress state poisoned");
|
|
state.step += 1;
|
|
state.phase = if state.step == 1 {
|
|
"analyzing request".to_string()
|
|
} else {
|
|
"reviewing findings".to_string()
|
|
};
|
|
state.detail = Some(format!("task: {}", state.task_label));
|
|
state.clone()
|
|
};
|
|
self.write_line(&format_internal_prompt_progress_line(
|
|
InternalPromptProgressEvent::Update,
|
|
&snapshot,
|
|
self.elapsed(),
|
|
None,
|
|
));
|
|
}
|
|
|
|
pub(crate) fn mark_tool_phase(&self, name: &str, input: &str) {
|
|
let detail = describe_tool_progress(name, input);
|
|
let snapshot = {
|
|
let mut state = self
|
|
.shared
|
|
.state
|
|
.lock()
|
|
.expect("internal prompt progress state poisoned");
|
|
state.step += 1;
|
|
state.phase = format!("running {name}");
|
|
state.detail = Some(detail);
|
|
state.clone()
|
|
};
|
|
self.write_line(&format_internal_prompt_progress_line(
|
|
InternalPromptProgressEvent::Update,
|
|
&snapshot,
|
|
self.elapsed(),
|
|
None,
|
|
));
|
|
}
|
|
|
|
pub(crate) fn mark_text_phase(&self, text: &str) {
|
|
let trimmed = text.trim();
|
|
if trimmed.is_empty() {
|
|
return;
|
|
}
|
|
let detail = truncate_for_summary(first_visible_line(trimmed), 120);
|
|
let snapshot = {
|
|
let mut state = self
|
|
.shared
|
|
.state
|
|
.lock()
|
|
.expect("internal prompt progress state poisoned");
|
|
if state.saw_final_text {
|
|
return;
|
|
}
|
|
state.saw_final_text = true;
|
|
state.step += 1;
|
|
state.phase = "drafting final plan".to_string();
|
|
state.detail = (!detail.is_empty()).then_some(detail);
|
|
state.clone()
|
|
};
|
|
self.write_line(&format_internal_prompt_progress_line(
|
|
InternalPromptProgressEvent::Update,
|
|
&snapshot,
|
|
self.elapsed(),
|
|
None,
|
|
));
|
|
}
|
|
|
|
pub(crate) fn emit_heartbeat(&self) {
|
|
let snapshot = self.snapshot();
|
|
self.write_line(&format_internal_prompt_progress_line(
|
|
InternalPromptProgressEvent::Heartbeat,
|
|
&snapshot,
|
|
self.elapsed(),
|
|
None,
|
|
));
|
|
}
|
|
|
|
pub(crate) fn snapshot(&self) -> InternalPromptProgressState {
|
|
self.shared
|
|
.state
|
|
.lock()
|
|
.expect("internal prompt progress state poisoned")
|
|
.clone()
|
|
}
|
|
|
|
pub(crate) fn elapsed(&self) -> Duration {
|
|
self.shared.started_at.elapsed()
|
|
}
|
|
|
|
pub(crate) fn write_line(&self, line: &str) {
|
|
let _guard = self
|
|
.shared
|
|
.output_lock
|
|
.lock()
|
|
.expect("internal prompt progress output lock poisoned");
|
|
let mut stdout = io::stdout();
|
|
let _ = writeln!(stdout, "{line}");
|
|
let _ = stdout.flush();
|
|
}
|
|
}
|
|
|
|
impl InternalPromptProgressRun {
|
|
pub(crate) fn start_ultraplan(task: &str) -> Self {
|
|
let reporter = InternalPromptProgressReporter::ultraplan(task);
|
|
reporter.emit(InternalPromptProgressEvent::Started, None);
|
|
|
|
let (heartbeat_stop, heartbeat_rx) = mpsc::channel();
|
|
let heartbeat_reporter = reporter.clone();
|
|
let heartbeat_handle = thread::spawn(move || loop {
|
|
match heartbeat_rx.recv_timeout(INTERNAL_PROGRESS_HEARTBEAT_INTERVAL) {
|
|
Ok(()) | Err(RecvTimeoutError::Disconnected) => break,
|
|
Err(RecvTimeoutError::Timeout) => heartbeat_reporter.emit_heartbeat(),
|
|
}
|
|
});
|
|
|
|
Self {
|
|
reporter,
|
|
heartbeat_stop: Some(heartbeat_stop),
|
|
heartbeat_handle: Some(heartbeat_handle),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn reporter(&self) -> InternalPromptProgressReporter {
|
|
self.reporter.clone()
|
|
}
|
|
|
|
pub(crate) fn finish_success(&mut self) {
|
|
self.stop_heartbeat();
|
|
self.reporter
|
|
.emit(InternalPromptProgressEvent::Complete, None);
|
|
}
|
|
|
|
pub(crate) fn finish_failure(&mut self, error: &str) {
|
|
self.stop_heartbeat();
|
|
self.reporter
|
|
.emit(InternalPromptProgressEvent::Failed, Some(error));
|
|
}
|
|
|
|
pub(crate) fn stop_heartbeat(&mut self) {
|
|
if let Some(sender) = self.heartbeat_stop.take() {
|
|
let _ = sender.send(());
|
|
}
|
|
if let Some(handle) = self.heartbeat_handle.take() {
|
|
let _ = handle.join();
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Drop for InternalPromptProgressRun {
|
|
fn drop(&mut self) {
|
|
self.stop_heartbeat();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn format_internal_prompt_progress_line(
|
|
event: InternalPromptProgressEvent,
|
|
snapshot: &InternalPromptProgressState,
|
|
elapsed: Duration,
|
|
error: Option<&str>,
|
|
) -> String {
|
|
let elapsed_seconds = elapsed.as_secs();
|
|
let step_label = if snapshot.step == 0 {
|
|
"current step pending".to_string()
|
|
} else {
|
|
format!("current step {}", snapshot.step)
|
|
};
|
|
let mut status_bits = vec![step_label, format!("phase {}", snapshot.phase)];
|
|
if let Some(detail) = snapshot
|
|
.detail
|
|
.as_deref()
|
|
.filter(|detail| !detail.is_empty())
|
|
{
|
|
status_bits.push(detail.to_string());
|
|
}
|
|
let status = status_bits.join(" · ");
|
|
match event {
|
|
InternalPromptProgressEvent::Started => {
|
|
format!(
|
|
"🧭 {} status · planning started · {status}",
|
|
snapshot.command_label
|
|
)
|
|
}
|
|
InternalPromptProgressEvent::Update => {
|
|
format!("… {} status · {status}", snapshot.command_label)
|
|
}
|
|
InternalPromptProgressEvent::Heartbeat => format!(
|
|
"… {} heartbeat · {elapsed_seconds}s elapsed · {status}",
|
|
snapshot.command_label
|
|
),
|
|
InternalPromptProgressEvent::Complete => format!(
|
|
"✔ {} status · completed · {elapsed_seconds}s elapsed · {} steps total",
|
|
snapshot.command_label, snapshot.step
|
|
),
|
|
InternalPromptProgressEvent::Failed => format!(
|
|
"✘ {} status · failed · {elapsed_seconds}s elapsed · {}",
|
|
snapshot.command_label,
|
|
error.unwrap_or("unknown error")
|
|
),
|
|
}
|
|
}
|
|
|
|
pub(crate) struct CliHookProgressReporter;
|
|
|
|
impl runtime::HookProgressReporter for CliHookProgressReporter {
|
|
fn on_event(&mut self, event: &runtime::HookProgressEvent) {
|
|
match event {
|
|
runtime::HookProgressEvent::Started {
|
|
event,
|
|
tool_name,
|
|
command,
|
|
} => eprintln!(
|
|
"[hook {event_name}] {tool_name}: {command}",
|
|
event_name = event.as_str()
|
|
),
|
|
runtime::HookProgressEvent::Completed {
|
|
event,
|
|
tool_name,
|
|
command,
|
|
} => eprintln!(
|
|
"[hook done {event_name}] {tool_name}: {command}",
|
|
event_name = event.as_str()
|
|
),
|
|
runtime::HookProgressEvent::Cancelled {
|
|
event,
|
|
tool_name,
|
|
command,
|
|
} => eprintln!(
|
|
"[hook cancelled {event_name}] {tool_name}: {command}",
|
|
event_name = event.as_str()
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn first_visible_line(text: &str) -> &str {
|
|
text.lines()
|
|
.find(|line| !line.trim().is_empty())
|
|
.unwrap_or(text)
|
|
}
|