1017 lines
38 KiB
Rust
1017 lines
38 KiB
Rust
//! App 状态与交互逻辑：命令、键盘/鼠标、后台任务粘合、会话持久化。
|
||
//! App state and interaction logic: commands, keyboard/mouse, job glue, and
|
||
//! session persistence.
|
||
|
||
use crate::config::{ProviderKind, TuiConfig};
|
||
use crate::format::display_width;
|
||
use crate::job::{JobEvent, RunJob};
|
||
use crate::state::*;
|
||
use focus_core::model::*;
|
||
use focus_harness::estimate_messages;
|
||
use focus_harness::prompt::{default_context, ContextUsage, SystemPromptTemplate};
|
||
use focus_harness::session::{SessionEntry, SessionStore};
|
||
use focus_providers::config::{known_context_window, resolve_context_window};
|
||
use std::collections::{HashMap, HashSet};
|
||
use std::path::PathBuf;
|
||
use std::sync::mpsc::{channel, Receiver};
|
||
use std::thread::JoinHandle;
|
||
use std::time::{SystemTime, UNIX_EPOCH};
|
||
|
||
/// 一个已渲染块的几何信息（行范围，供点击映射）。
|
||
/// Geometry of one rendered block (line range, for click mapping).
|
||
#[derive(Debug, Clone)]
|
||
pub struct BlockGeometry {
|
||
pub id: BlockId,
|
||
/// 内容坐标中的起始行（含）。
|
||
/// Start line in content coordinates (inclusive).
|
||
pub start: u16,
|
||
/// 内容坐标中的结束行（不含）。
|
||
/// End line in content coordinates (exclusive).
|
||
pub end: u16,
|
||
}
|
||
|
||
/// 配置表单的字段。
|
||
/// A config-form field.
|
||
#[derive(Debug, Clone)]
|
||
pub enum FormField {
|
||
/// 单选。
|
||
/// A choice.
|
||
Choice {
|
||
label: String,
|
||
options: Vec<String>,
|
||
selected: usize,
|
||
},
|
||
/// 文本输入。
|
||
/// Text input.
|
||
Text { label: String, value: String },
|
||
}
|
||
|
||
impl FormField {
|
||
pub fn label(&self) -> &str {
|
||
match self {
|
||
FormField::Choice { label, .. } => label,
|
||
FormField::Text { label, .. } => label,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 配置编辑表单。
|
||
/// The config-editing form.
|
||
#[derive(Debug, Clone)]
|
||
pub struct ConfigForm {
|
||
pub fields: Vec<FormField>,
|
||
pub active: usize,
|
||
}
|
||
|
||
impl ConfigForm {
|
||
/// 从当前配置构建表单。
|
||
/// Build the form from the current config.
|
||
pub fn from_config(cfg: &TuiConfig) -> Self {
|
||
let protocol = match cfg.openai_protocol {
|
||
focus_providers::openai::OpenAiProtocol::Responses => "responses",
|
||
focus_providers::openai::OpenAiProtocol::ChatCompletions => "chatCompletions",
|
||
};
|
||
Self {
|
||
fields: vec![
|
||
FormField::Choice {
|
||
label: "provider".into(),
|
||
options: vec!["anthropic".into(), "openai".into()],
|
||
selected: match cfg.provider {
|
||
ProviderKind::Anthropic => 0,
|
||
ProviderKind::OpenAI => 1,
|
||
},
|
||
},
|
||
FormField::Choice {
|
||
label: "openaiProtocol".into(),
|
||
options: vec!["responses".into(), "chatCompletions".into()],
|
||
selected: if protocol == "chatCompletions" { 1 } else { 0 },
|
||
},
|
||
FormField::Text {
|
||
label: "baseUrl".into(),
|
||
value: cfg.base_url.clone().unwrap_or_default(),
|
||
},
|
||
FormField::Text {
|
||
label: "apiKey".into(),
|
||
value: cfg.api_key.clone(),
|
||
},
|
||
FormField::Text {
|
||
label: "model".into(),
|
||
value: cfg.model.clone(),
|
||
},
|
||
FormField::Text {
|
||
label: "contextWindow".into(),
|
||
value: cfg
|
||
.context_window
|
||
.map(|w| w.to_string())
|
||
.unwrap_or_default(),
|
||
},
|
||
],
|
||
active: 0,
|
||
}
|
||
}
|
||
|
||
/// 把表单写回配置（空字符串 → None）。
|
||
/// Write the form back into the config (empty string → None).
|
||
pub fn apply(self, cfg: &mut TuiConfig) {
|
||
for field in self.fields {
|
||
match field {
|
||
FormField::Choice {
|
||
label, selected, ..
|
||
} => match label.as_str() {
|
||
"provider" => {
|
||
cfg.provider = if selected == 1 {
|
||
ProviderKind::OpenAI
|
||
} else {
|
||
ProviderKind::Anthropic
|
||
}
|
||
}
|
||
"openaiProtocol" => {
|
||
cfg.openai_protocol = if selected == 1 {
|
||
focus_providers::openai::OpenAiProtocol::ChatCompletions
|
||
} else {
|
||
focus_providers::openai::OpenAiProtocol::Responses
|
||
}
|
||
}
|
||
_ => {}
|
||
},
|
||
FormField::Text { label, value } => {
|
||
let value = value.trim().to_string();
|
||
match label.as_str() {
|
||
"baseUrl" => {
|
||
cfg.base_url = if value.is_empty() { None } else { Some(value) }
|
||
}
|
||
"apiKey" => cfg.api_key = value,
|
||
"model" => {
|
||
if !value.is_empty() {
|
||
cfg.model = value;
|
||
}
|
||
}
|
||
"contextWindow" => {
|
||
cfg.context_window = value.parse::<u64>().ok().filter(|w| *w > 0)
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 会话列表表单。
|
||
/// The session-list form.
|
||
#[derive(Debug, Clone)]
|
||
pub struct SessionsForm {
|
||
pub sessions: Vec<String>,
|
||
pub selected: usize,
|
||
}
|
||
|
||
/// 打开的模态框。
|
||
/// An open modal.
|
||
#[derive(Debug, Clone)]
|
||
pub enum Modal {
|
||
Config(ConfigForm),
|
||
Sessions(SessionsForm),
|
||
Help,
|
||
}
|
||
|
||
/// 交互式应用状态。
|
||
/// The interactive app state.
|
||
#[derive(Debug)]
|
||
pub struct App {
|
||
pub config: TuiConfig,
|
||
pub transcript: Vec<Message>,
|
||
/// 已写入会话的消息数。
|
||
/// Messages already written to the session.
|
||
pub persisted: usize,
|
||
pub session_id: Option<String>,
|
||
pub last_entry_id: Option<String>,
|
||
pub session_seq: u64,
|
||
pub store: SessionStore,
|
||
pub input: String,
|
||
pub caret: usize,
|
||
pub run_rx: Option<Receiver<JobEvent>>,
|
||
pub run_join: Option<JoinHandle<()>>,
|
||
pub run_state: Option<RunState>,
|
||
/// 已提交 assistant 消息的思考耗时（(消息索引, 内容索引) → 毫秒）。
|
||
/// Committed assistant thinking durations ((message idx, content idx) → ms).
|
||
pub thinking_durations: HashMap<(usize, usize), u64>,
|
||
/// 已提交 tool_result 消息的执行耗时（(消息索引, 0) → 毫秒）。
|
||
/// Committed tool_result execution durations ((message idx, 0) → ms).
|
||
pub tool_durations: HashMap<(usize, usize), u64>,
|
||
pub expanded: HashSet<BlockId>,
|
||
/// 二级展开（显示全部内容）的块。
|
||
/// Blocks expanded to the full level (show everything).
|
||
pub full: HashSet<BlockId>,
|
||
pub notes: Vec<String>,
|
||
pub status: String,
|
||
pub scroll: u16,
|
||
pub follow: bool,
|
||
pub modal: Option<Modal>,
|
||
pub last_usage: Option<Usage>,
|
||
/// 最近一次渲染的块几何（供点击映射），由 draw 填充。
|
||
/// Geometry of the last render (for click mapping); filled by draw.
|
||
pub geometry: Vec<BlockGeometry>,
|
||
/// 消息区视图高度（由 draw 填充）。
|
||
/// Messages-area view height (filled by draw).
|
||
pub view_height: u16,
|
||
/// 消息区总内容行数（由 draw 填充；滚动上限依据）。
|
||
/// Total content lines of the message area (filled by draw; the scroll
|
||
/// limit is based on it).
|
||
pub content_lines: u16,
|
||
/// 帧计数（供 spinner 动画）。
|
||
/// Frame counter (drives the spinner animation).
|
||
pub frame: u64,
|
||
pub quit: bool,
|
||
}
|
||
|
||
impl App {
|
||
/// 创建一个新应用（加载配置与默认数据目录）。
|
||
/// Create a new app (loading the config and default data dir).
|
||
pub fn new() -> Self {
|
||
Self {
|
||
config: TuiConfig::load(),
|
||
transcript: Vec::new(),
|
||
persisted: 0,
|
||
session_id: None,
|
||
last_entry_id: None,
|
||
session_seq: 0,
|
||
store: SessionStore::default(),
|
||
input: String::new(),
|
||
caret: 0,
|
||
run_rx: None,
|
||
run_join: None,
|
||
run_state: None,
|
||
thinking_durations: HashMap::new(),
|
||
tool_durations: HashMap::new(),
|
||
expanded: HashSet::new(),
|
||
full: HashSet::new(),
|
||
notes: Vec::new(),
|
||
status: String::new(),
|
||
scroll: 0,
|
||
follow: true,
|
||
modal: None,
|
||
last_usage: None,
|
||
geometry: Vec::new(),
|
||
view_height: 0,
|
||
content_lines: 0,
|
||
frame: 0,
|
||
quit: false,
|
||
}
|
||
}
|
||
|
||
/// 推送一条系统说明（显示在消息区顶部）。
|
||
/// Push a system note (shown at the top of the message area).
|
||
pub fn push_note(&mut self, text: impl Into<String>) {
|
||
self.notes.push(text.into());
|
||
}
|
||
|
||
/// 是否正在运行任务。
|
||
/// Whether a job is running.
|
||
pub fn is_running(&self) -> bool {
|
||
self.run_rx.is_some()
|
||
}
|
||
|
||
/// 会话是否已存在（否则在首次发送时创建）。
|
||
/// Whether a session exists (created on first send otherwise).
|
||
pub fn ensure_session(&mut self) {
|
||
if self.session_id.is_none() {
|
||
let secs = SystemTime::now()
|
||
.duration_since(UNIX_EPOCH)
|
||
.map(|d| d.as_secs())
|
||
.unwrap_or(0);
|
||
self.session_id = Some(format!("s{}-{}", secs, self.session_seq));
|
||
self.session_seq += 1;
|
||
}
|
||
}
|
||
|
||
/// 把消息写入当前会话（增量）。
|
||
/// Write messages into the current session (incrementally).
|
||
pub fn persist_entries(&mut self, messages: &[Message]) {
|
||
let Some(sid) = self.session_id.clone() else {
|
||
return;
|
||
};
|
||
for m in messages {
|
||
let id = match self.store.next_entry_id(&sid) {
|
||
Ok(i) => i,
|
||
Err(_) => return,
|
||
};
|
||
let entry = SessionEntry::new(id.clone(), self.last_entry_id.clone(), m.clone());
|
||
if self.store.append(&sid, &entry).is_err() {
|
||
return;
|
||
}
|
||
self.last_entry_id = Some(id);
|
||
self.persisted += 1;
|
||
}
|
||
}
|
||
|
||
/// 渲染当前系统提示（含 Usage/上下文占用）。
|
||
/// Render the current system prompt (with usage / context occupancy).
|
||
fn render_system_prompt(&self) -> String {
|
||
let model = self.config.model.clone();
|
||
let window = resolve_context_window(self.config.context_window, &model);
|
||
let window_known =
|
||
self.config.context_window.is_some() || known_context_window(&model).is_some();
|
||
let mut ctx = default_context();
|
||
ctx.context_usage = Some(ContextUsage {
|
||
estimated_tokens: estimate_messages(&self.transcript),
|
||
context_window: window,
|
||
window_known,
|
||
});
|
||
ctx.last_usage = self.last_usage.clone();
|
||
SystemPromptTemplate::default().render(&ctx)
|
||
}
|
||
|
||
/// 发送一条消息（若以 `/` 开头则视为命令）。
|
||
/// Send a message (commands start with `/`).
|
||
pub fn send(&mut self, text: &str) {
|
||
let trimmed = text.trim();
|
||
if trimmed.is_empty() {
|
||
return;
|
||
}
|
||
if let Some(cmd) = trimmed.strip_prefix('/') {
|
||
self.handle_command(cmd);
|
||
return;
|
||
}
|
||
if !self.config.is_ready() {
|
||
self.status = "⚠ 未配置：请先运行 /config".into();
|
||
return;
|
||
}
|
||
if self.is_running() {
|
||
self.status = "⚠ 已有任务在运行".into();
|
||
return;
|
||
}
|
||
self.ensure_session();
|
||
// 用户消息先入 UI 的 transcript 用于即时显示；持久化由后台任务完成
|
||
// （job 的 to_persist 会包含它），避免与 agent 循环重复写入。
|
||
// The user message enters the UI transcript for immediate display;
|
||
// persistence happens in the background job (its to_persist includes
|
||
// it), avoiding a duplicate write with the agent loop.
|
||
let user = Message::user_text(text.to_string());
|
||
self.transcript.push(user);
|
||
self.input.clear();
|
||
self.caret = 0;
|
||
self.follow = true;
|
||
self.status.clear(); // 动画 spinner 指示运行中 / the animated spinner shows "working"
|
||
self.spawn_job(Some(text.to_string()));
|
||
}
|
||
|
||
/// 继续对话（对最后一条 assistant 消息再追问）。
|
||
/// Continue the conversation (re-prompt after an assistant turn).
|
||
pub fn r#continue(&mut self) {
|
||
self.send("continue");
|
||
}
|
||
|
||
/// 启动后台任务（prompt 或仅压缩）。
|
||
/// Spawn a background job (prompt or compact-only).
|
||
fn spawn_job(&mut self, user_text: Option<String>) {
|
||
let (tx, rx) = channel::<JobEvent>();
|
||
let system_prompt = self.render_system_prompt();
|
||
// 给任务的 transcript 不含刚加入的用户消息——agent 循环会把它加入并
|
||
// 计入 to_persist，从而避免重复持久化。
|
||
// The job's transcript excludes the just-added user message — the
|
||
// agent loop adds it back and it lands in to_persist, avoiding
|
||
// duplicate persistence.
|
||
let job_transcript = match &user_text {
|
||
Some(_) => self.transcript[..self.transcript.len().saturating_sub(1)].to_vec(),
|
||
None => self.transcript.clone(),
|
||
};
|
||
let job = RunJob {
|
||
transcript: job_transcript,
|
||
user_text,
|
||
config: self.config.clone(),
|
||
cwd: std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")),
|
||
system_prompt,
|
||
provider: None,
|
||
};
|
||
let join = crate::job::spawn(job, tx);
|
||
self.run_rx = Some(rx);
|
||
self.run_join = Some(join);
|
||
self.run_state = Some(RunState::new(real_clock()));
|
||
}
|
||
|
||
/// 排空后台任务事件。
|
||
/// Drain background job events.
|
||
pub fn drain_job_events(&mut self) {
|
||
let rx = match self.run_rx.take() {
|
||
Some(rx) => rx,
|
||
None => return,
|
||
};
|
||
let mut finished = false;
|
||
while let Ok(ev) = rx.try_recv() {
|
||
if matches!(ev, JobEvent::Done { .. }) {
|
||
finished = true;
|
||
}
|
||
self.on_job_event(ev);
|
||
}
|
||
if finished {
|
||
self.run_join = None;
|
||
self.run_state = None;
|
||
} else {
|
||
self.run_rx = Some(rx);
|
||
}
|
||
}
|
||
|
||
/// 处理一个后台事件。
|
||
/// Handle one background event.
|
||
fn on_job_event(&mut self, ev: JobEvent) {
|
||
match ev {
|
||
JobEvent::Agent(ev) => {
|
||
if let Some(rs) = &mut self.run_state {
|
||
rs.on_agent_event(&ev);
|
||
}
|
||
}
|
||
JobEvent::Note(n) => self.status = n,
|
||
JobEvent::Done {
|
||
messages,
|
||
to_persist,
|
||
appended_count,
|
||
error,
|
||
} => {
|
||
// 收尾思考计时并映射到已提交消息。
|
||
// Finalize thinking timings and map them onto committed
|
||
// messages.
|
||
if let Some(rs) = &mut self.run_state {
|
||
rs.finalize();
|
||
let tail_start = messages.len().saturating_sub(appended_count);
|
||
let mut turn = 0usize;
|
||
for (off, msg) in messages.iter().enumerate().skip(tail_start) {
|
||
match msg {
|
||
Message::Assistant(a) => {
|
||
for (bi, block) in a.content.iter().enumerate() {
|
||
if let ContentBlock::Thinking(_) = block {
|
||
if let Some(timing) = rs.thinking.get(&(turn, bi)) {
|
||
self.thinking_durations
|
||
.insert((off, bi), timing.duration_ms());
|
||
}
|
||
}
|
||
}
|
||
turn += 1;
|
||
}
|
||
Message::ToolResult(t) => {
|
||
// 把该轮的工具执行耗时映射到 tool_result 消息。
|
||
// Map the tool-execution duration onto the
|
||
// tool_result message.
|
||
if let Some(exec) = rs
|
||
.tool_execs
|
||
.iter()
|
||
.find(|e| e.tool_call_id == t.tool_call_id)
|
||
{
|
||
if let Some(d) = exec.duration_ms() {
|
||
self.tool_durations.insert((off, 0), d);
|
||
}
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
}
|
||
|
||
self.persist_entries(&to_persist);
|
||
self.transcript = messages;
|
||
// 错误优先取 job 报告的 error；若错误被编码成消息（如 provider 的
|
||
// HTTP 400 → StreamEvent::Error → assistant error 消息），
|
||
// 从最后一条 assistant 消息的 error_message 提取。
|
||
// Prefer the job's reported error; when the error is encoded as
|
||
// a message (provider HTTP 400 → StreamEvent::Error → an
|
||
// assistant error message), extract it from the last assistant.
|
||
let surfaced = error.or_else(|| {
|
||
self.transcript.iter().rev().find_map(|m| match m {
|
||
Message::Assistant(a) if a.stop_reason == StopReason::Error => {
|
||
a.error_message.clone()
|
||
}
|
||
_ => None,
|
||
})
|
||
});
|
||
if let Some(err) = surfaced {
|
||
self.status = format!("⚠ {}", crate::format::truncate(&err, 80));
|
||
self.push_note(format!("运行出错：{}", err));
|
||
} else {
|
||
self.status = "✓ 完成".into();
|
||
}
|
||
if let Some(last) = self.transcript.iter().rev().find_map(|m| match m {
|
||
Message::Assistant(a) => Some(a.usage.clone()),
|
||
_ => None,
|
||
}) {
|
||
self.last_usage = Some(last);
|
||
}
|
||
self.follow = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 中止当前运行（放弃该任务，线程随超时自然结束）。
|
||
/// Abort the current run (abandon the job; the thread ends within its
|
||
/// timeout).
|
||
pub fn abort_run(&mut self) {
|
||
if self.run_rx.is_none() {
|
||
return;
|
||
}
|
||
self.run_rx = None;
|
||
self.run_join = None;
|
||
let aborted = if let Some(rs) = &mut self.run_state {
|
||
rs.finalize();
|
||
match rs.partial.clone() {
|
||
Some(mut p) => {
|
||
p.stop_reason = StopReason::Aborted;
|
||
p.error_message = Some("aborted by user".into());
|
||
p
|
||
}
|
||
None => AssistantMessage {
|
||
content: Vec::new(),
|
||
model: self.config.model.clone(),
|
||
usage: Usage::default(),
|
||
stop_reason: StopReason::Aborted,
|
||
error_message: Some("aborted by user".into()),
|
||
timestamp: now_ms(),
|
||
},
|
||
}
|
||
} else {
|
||
AssistantMessage {
|
||
content: Vec::new(),
|
||
model: self.config.model.clone(),
|
||
usage: Usage::default(),
|
||
stop_reason: StopReason::Aborted,
|
||
error_message: Some("aborted by user".into()),
|
||
timestamp: now_ms(),
|
||
}
|
||
};
|
||
self.transcript.push(Message::Assistant(aborted));
|
||
let tail = self
|
||
.transcript
|
||
.get(self.persisted..)
|
||
.unwrap_or_default()
|
||
.to_vec();
|
||
self.persist_entries(&tail);
|
||
self.run_state = None;
|
||
self.status = "⏹ 已中止".into();
|
||
self.follow = true;
|
||
}
|
||
|
||
/// 开始新会话。
|
||
/// Start a new session.
|
||
pub fn new_session(&mut self) {
|
||
if self.is_running() {
|
||
self.status = "⚠ 任务运行中，无法切换会话".into();
|
||
return;
|
||
}
|
||
self.transcript.clear();
|
||
self.persisted = 0;
|
||
self.session_id = None;
|
||
self.last_entry_id = None;
|
||
self.thinking_durations.clear();
|
||
self.tool_durations.clear();
|
||
self.expanded.clear();
|
||
self.full.clear();
|
||
self.last_usage = None;
|
||
self.notes.clear();
|
||
self.push_note("新会话已开始。");
|
||
self.scroll = 0;
|
||
self.follow = true;
|
||
}
|
||
|
||
/// 加载一个会话（替换 transcript）。
|
||
/// Load a session (replacing the transcript).
|
||
pub fn load_session(&mut self, session_id: &str) {
|
||
let entries = match self.store.load(session_id) {
|
||
Ok(e) => e,
|
||
Err(e) => {
|
||
self.status = format!("⚠ 加载会话失败：{}", e);
|
||
return;
|
||
}
|
||
};
|
||
let messages: Vec<Message> = entries.iter().map(|e| e.message.clone()).collect();
|
||
self.transcript = messages;
|
||
self.persisted = entries.len();
|
||
self.session_id = Some(session_id.to_string());
|
||
self.last_entry_id = entries.last().map(|e| e.id.clone());
|
||
self.thinking_durations.clear();
|
||
self.tool_durations.clear();
|
||
self.expanded.clear();
|
||
self.full.clear();
|
||
self.notes.clear();
|
||
self.push_note(format!(
|
||
"已加载会话 {}（{} 条消息）。",
|
||
session_id,
|
||
entries.len()
|
||
));
|
||
if let Some(last) = self.transcript.iter().rev().find_map(|m| match m {
|
||
Message::Assistant(a) => Some(a.usage.clone()),
|
||
_ => None,
|
||
}) {
|
||
self.last_usage = Some(last);
|
||
}
|
||
self.scroll = 0;
|
||
self.follow = true;
|
||
}
|
||
|
||
/// 执行一条命令（不含前导 `/`）。
|
||
/// Run a command (without the leading `/`).
|
||
fn handle_command(&mut self, cmd: &str) {
|
||
match cmd.trim() {
|
||
"new" => self.new_session(),
|
||
"sessions" => {
|
||
if self.is_running() {
|
||
self.status = "⚠ 任务运行中".into();
|
||
return;
|
||
}
|
||
match self.store.list_sessions() {
|
||
Ok(sessions) => {
|
||
if sessions.is_empty() {
|
||
self.status = "暂无历史会话".into();
|
||
} else {
|
||
self.modal = Some(Modal::Sessions(SessionsForm {
|
||
sessions,
|
||
selected: 0,
|
||
}));
|
||
}
|
||
}
|
||
Err(e) => self.status = format!("⚠ {}", e),
|
||
}
|
||
}
|
||
"config" => {
|
||
if self.is_running() {
|
||
self.status = "⚠ 任务运行中".into();
|
||
return;
|
||
}
|
||
self.modal = Some(Modal::Config(ConfigForm::from_config(&self.config)));
|
||
}
|
||
"compact" => {
|
||
if !self.config.is_ready() {
|
||
self.status = "⚠ 未配置".into();
|
||
return;
|
||
}
|
||
if self.is_running() {
|
||
self.status = "⚠ 已有任务在运行".into();
|
||
return;
|
||
}
|
||
if self.transcript.is_empty() {
|
||
self.status = "无内容可压缩".into();
|
||
return;
|
||
}
|
||
self.ensure_session();
|
||
self.status = "▶ compacting…".into();
|
||
self.spawn_job(None);
|
||
}
|
||
"help" => {
|
||
self.modal = Some(Modal::Help);
|
||
}
|
||
other => {
|
||
self.status = format!("未知命令：/{}（/help 查看帮助）", other);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 处理一个键盘事件。返回 true 表示退出。
|
||
/// Handle a key event. Returns true to quit.
|
||
pub fn handle_key(&mut self, key: crossterm::event::KeyEvent) -> bool {
|
||
use crossterm::event::{KeyCode, KeyEventKind, KeyModifiers};
|
||
if key.kind != KeyEventKind::Press {
|
||
return false;
|
||
}
|
||
// Ctrl+C 永远退出。
|
||
// Ctrl+C always quits.
|
||
if key.code == KeyCode::Char('c') && key.modifiers.contains(KeyModifiers::CONTROL) {
|
||
self.quit = true;
|
||
return true;
|
||
}
|
||
|
||
if let Some(modal) = self.modal.take() {
|
||
if let Some(kept) = self.handle_modal_key(modal, key) {
|
||
self.modal = Some(kept);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
match key.code {
|
||
KeyCode::Esc => {
|
||
if self.is_running() {
|
||
self.abort_run();
|
||
} else {
|
||
self.quit = true;
|
||
}
|
||
}
|
||
KeyCode::Enter => {
|
||
if key.modifiers.contains(KeyModifiers::SHIFT) {
|
||
self.insert_char('\n');
|
||
} else {
|
||
let text = self.input.clone();
|
||
if !text.trim().is_empty() {
|
||
self.send(&text);
|
||
}
|
||
}
|
||
}
|
||
KeyCode::Tab => self.toggle_latest_collapsible(),
|
||
KeyCode::Backspace => self.backspace(),
|
||
KeyCode::Delete => self.delete(),
|
||
KeyCode::Left => self.move_caret(-1),
|
||
KeyCode::Right => self.move_caret(1),
|
||
KeyCode::Home => {
|
||
self.caret = self.line_start(self.caret);
|
||
}
|
||
KeyCode::End => {
|
||
self.caret = self.line_end(self.caret);
|
||
}
|
||
KeyCode::PageUp => {
|
||
// 向上翻页：减小内容偏移（scroll 为内容偏移量）。
|
||
// Page up: decrease the content offset.
|
||
self.follow = false;
|
||
self.scroll = self.scroll.saturating_sub(self.view_height.max(1));
|
||
}
|
||
KeyCode::PageDown => {
|
||
self.scroll = (self.scroll + self.view_height.max(1)).min(self.max_scroll());
|
||
self.follow = self.scroll >= self.max_scroll();
|
||
}
|
||
KeyCode::Up => {
|
||
if self.input.is_empty() {
|
||
// 输入为空时 ↑↓ 滚动消息区（否则用于移动光标）。
|
||
// Up/Down scroll the messages when the input is empty
|
||
// (otherwise they move the caret).
|
||
self.follow = false;
|
||
self.scroll = self.scroll.saturating_sub(1);
|
||
} else {
|
||
self.move_caret_line(-1);
|
||
}
|
||
}
|
||
KeyCode::Down => {
|
||
if self.input.is_empty() {
|
||
self.scroll = (self.scroll + 1).min(self.max_scroll());
|
||
self.follow = self.scroll >= self.max_scroll();
|
||
} else {
|
||
self.move_caret_line(1);
|
||
}
|
||
}
|
||
KeyCode::Char(c) => {
|
||
// Ctrl+U 逐行向上滚动（vim 风格）。
|
||
// Ctrl+U scrolls up line-by-line (vim style).
|
||
if c == 'u' && key.modifiers.contains(KeyModifiers::CONTROL) {
|
||
self.follow = false;
|
||
self.scroll = self.scroll.saturating_sub(1);
|
||
return false;
|
||
}
|
||
// Ctrl+D 继续。
|
||
// Ctrl+D continues.
|
||
if c == 'd' && key.modifiers.contains(KeyModifiers::CONTROL) {
|
||
if self.is_running() {
|
||
self.status = "⚠ 任务运行中".into();
|
||
} else if self.config.is_ready() && !self.transcript.is_empty() {
|
||
self.r#continue();
|
||
}
|
||
return false;
|
||
}
|
||
self.insert_char(c);
|
||
}
|
||
_ => {}
|
||
}
|
||
false
|
||
}
|
||
|
||
/// 处理模态框内的键盘事件。返回 `Some` 表示保持打开，`None` 表示关闭。
|
||
/// Handle a key event inside a modal. Returns `Some` to keep it open,
|
||
/// `None` to close it.
|
||
fn handle_modal_key(&mut self, modal: Modal, key: crossterm::event::KeyEvent) -> Option<Modal> {
|
||
use crossterm::event::{KeyCode, KeyModifiers};
|
||
match modal {
|
||
Modal::Help => {
|
||
// 任意键关闭帮助。
|
||
// Any key closes help.
|
||
None
|
||
}
|
||
Modal::Config(mut form) => match key.code {
|
||
KeyCode::Esc => None,
|
||
KeyCode::Enter => {
|
||
form.apply(&mut self.config);
|
||
if let Err(e) = self.config.save() {
|
||
self.status = format!("⚠ 保存配置失败：{}", e);
|
||
} else {
|
||
self.status = "✓ 配置已保存".into();
|
||
}
|
||
None
|
||
}
|
||
KeyCode::Up | KeyCode::BackTab => {
|
||
form.active = (form.active + form.fields.len() - 1) % form.fields.len();
|
||
Some(Modal::Config(form))
|
||
}
|
||
KeyCode::Down | KeyCode::Tab => {
|
||
form.active = (form.active + 1) % form.fields.len();
|
||
Some(Modal::Config(form))
|
||
}
|
||
KeyCode::Left => {
|
||
if let FormField::Choice { selected, .. } = &mut form.fields[form.active] {
|
||
*selected = selected.saturating_sub(1);
|
||
}
|
||
Some(Modal::Config(form))
|
||
}
|
||
KeyCode::Right => {
|
||
if let FormField::Choice {
|
||
options, selected, ..
|
||
} = &mut form.fields[form.active]
|
||
{
|
||
*selected = (*selected + 1).min(options.len().saturating_sub(1));
|
||
}
|
||
Some(Modal::Config(form))
|
||
}
|
||
KeyCode::Backspace => {
|
||
if let FormField::Text { value, .. } = &mut form.fields[form.active] {
|
||
value.pop();
|
||
}
|
||
Some(Modal::Config(form))
|
||
}
|
||
KeyCode::Char(c) => {
|
||
if c == 'c' && key.modifiers.contains(KeyModifiers::CONTROL) {
|
||
return None;
|
||
}
|
||
if let FormField::Text { value, .. } = &mut form.fields[form.active] {
|
||
value.push(c);
|
||
}
|
||
Some(Modal::Config(form))
|
||
}
|
||
_ => Some(Modal::Config(form)),
|
||
},
|
||
Modal::Sessions(mut form) => match key.code {
|
||
KeyCode::Esc => None,
|
||
KeyCode::Up => {
|
||
form.selected = form.selected.saturating_sub(1);
|
||
Some(Modal::Sessions(form))
|
||
}
|
||
KeyCode::Down => {
|
||
form.selected = (form.selected + 1).min(form.sessions.len().saturating_sub(1));
|
||
Some(Modal::Sessions(form))
|
||
}
|
||
KeyCode::Enter => {
|
||
if let Some(id) = form.sessions.get(form.selected) {
|
||
let id = id.clone();
|
||
self.load_session(&id);
|
||
}
|
||
None
|
||
}
|
||
_ => Some(Modal::Sessions(form)),
|
||
},
|
||
}
|
||
}
|
||
|
||
/// 处理鼠标事件（点击展开/折叠，滚轮滚动）。
|
||
/// Handle a mouse event (click toggles expand, wheel scrolls).
|
||
pub fn handle_mouse(&mut self, m: crossterm::event::MouseEvent) {
|
||
use crossterm::event::MouseEventKind;
|
||
match m.kind {
|
||
MouseEventKind::Down(crossterm::event::MouseButton::Left) => {
|
||
// 只处理消息区内的点击。
|
||
// Only clicks inside the messages area.
|
||
if m.row < self.view_height {
|
||
let content_row = m.row + self.scroll;
|
||
if let Some(block) = self
|
||
.geometry
|
||
.iter()
|
||
.find(|g| g.start <= content_row && content_row < g.end)
|
||
{
|
||
cycle_expansion(&mut self.expanded, &mut self.full, &block.id);
|
||
}
|
||
}
|
||
}
|
||
// crossterm 把 Linux（xterm 协议）与 Windows（ConPTY）的滚轮事件
|
||
// 都归一化为 ScrollUp/ScrollDown。注意方向：scroll 是内容偏移量，
|
||
// 向上滚（看更早内容）要减小偏移，向下滚才增大；每格 1 行，逐行滚动。
|
||
// 向上滚必须取消 follow，否则每次绘制会被吸回底部。
|
||
// crossterm normalizes wheel events from both Linux (xterm) and
|
||
// Windows (ConPTY) to ScrollUp/ScrollDown. Direction: `scroll` is
|
||
// the content offset, so scrolling up (older content) decreases
|
||
// it and scrolling down increases it; one line per notch.
|
||
// Scrolling up must clear follow, otherwise every draw snaps back.
|
||
MouseEventKind::ScrollUp | MouseEventKind::ScrollLeft => {
|
||
self.follow = false;
|
||
self.scroll = self.scroll.saturating_sub(1);
|
||
}
|
||
MouseEventKind::ScrollDown | MouseEventKind::ScrollRight => {
|
||
self.scroll = (self.scroll + 1).min(self.max_scroll());
|
||
self.follow = self.scroll >= self.max_scroll();
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
/// 把输入框的滚动对齐到底部（跟随模式）。
|
||
/// Align the scroll to the bottom when following.
|
||
pub fn clamp_scroll(&mut self) {
|
||
if self.follow {
|
||
self.scroll = self.max_scroll();
|
||
}
|
||
}
|
||
|
||
/// 最大滚动偏移（由最近渲染的总行数决定；几何只含可展开块，不能用作依据）。
|
||
/// Max scroll offset (based on the last render's total line count; the
|
||
/// geometry only covers expandable blocks and is unusable for this).
|
||
fn max_scroll(&self) -> u16 {
|
||
self.content_lines.saturating_sub(self.view_height.max(1))
|
||
}
|
||
|
||
/// 切换最近一个可折叠块（几何只含可展开块：思考与工具）。
|
||
/// Toggle the most recent collapsible block (geometry only holds
|
||
/// expandable blocks: thinking and tools).
|
||
fn toggle_latest_collapsible(&mut self) {
|
||
if let Some(id) = self.geometry.last().map(|g| g.id.clone()) {
|
||
cycle_expansion(&mut self.expanded, &mut self.full, &id);
|
||
}
|
||
}
|
||
|
||
// ---- 输入编辑 ----
|
||
// ---- input editing ----------------------------------------------------
|
||
|
||
fn insert_char(&mut self, c: char) {
|
||
self.input.insert(self.caret, c);
|
||
self.caret += c.len_utf8();
|
||
}
|
||
|
||
fn backspace(&mut self) {
|
||
if let Some((idx, _len)) = self.input[..self.caret].char_indices().next_back() {
|
||
self.input.replace_range(idx..self.caret, "");
|
||
self.caret = idx;
|
||
}
|
||
}
|
||
|
||
fn delete(&mut self) {
|
||
if self.caret < self.input.len() {
|
||
let len = self.input[self.caret..]
|
||
.chars()
|
||
.next()
|
||
.map(|c| c.len_utf8())
|
||
.unwrap_or(0);
|
||
self.input.replace_range(self.caret..self.caret + len, "");
|
||
}
|
||
}
|
||
|
||
fn move_caret(&mut self, dir: i32) {
|
||
if dir < 0 {
|
||
if let Some((idx, _)) = self.input[..self.caret].char_indices().next_back() {
|
||
self.caret = idx;
|
||
}
|
||
} else if self.caret < self.input.len() {
|
||
let len = self.input[self.caret..]
|
||
.chars()
|
||
.next()
|
||
.map(|c| c.len_utf8())
|
||
.unwrap_or(0);
|
||
self.caret += len;
|
||
}
|
||
}
|
||
|
||
fn line_start(&self, pos: usize) -> usize {
|
||
self.input[..pos].rfind('\n').map(|i| i + 1).unwrap_or(0)
|
||
}
|
||
|
||
fn line_end(&self, pos: usize) -> usize {
|
||
self.input[pos..]
|
||
.find('\n')
|
||
.map(|i| pos + i)
|
||
.unwrap_or(self.input.len())
|
||
}
|
||
|
||
fn move_caret_line(&mut self, dir: i32) {
|
||
let line_start = self.line_start(self.caret);
|
||
let line_end = self.line_end(self.caret);
|
||
let col = display_width(&self.input[line_start..self.caret]);
|
||
if dir < 0 {
|
||
if line_start == 0 {
|
||
self.caret = 0;
|
||
return;
|
||
}
|
||
let prev_line_end = line_start - 1; // '\n' 的位置 / the '\n' position
|
||
let prev_start = self.input[..prev_line_end]
|
||
.rfind('\n')
|
||
.map(|i| i + 1)
|
||
.unwrap_or(0);
|
||
self.caret = prev_start + position_at_col(&self.input[prev_start..prev_line_end], col);
|
||
} else {
|
||
if line_end == self.input.len() {
|
||
self.caret = self.input.len();
|
||
return;
|
||
}
|
||
let next_start = line_end + 1;
|
||
let next_end = self.input[next_start..]
|
||
.find('\n')
|
||
.map(|i| next_start + i)
|
||
.unwrap_or(self.input.len());
|
||
self.caret = next_start + position_at_col(&self.input[next_start..next_end], col);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 在 `s` 中定位显示宽度 `col` 对应的字节偏移（尽力而为）。
|
||
/// Byte offset in `s` for a display column (best effort).
|
||
fn position_at_col(s: &str, col: usize) -> usize {
|
||
let mut w = 0usize;
|
||
for (i, c) in s.char_indices() {
|
||
let cw = crate::format::display_width_char(c);
|
||
if w + cw > col {
|
||
return i;
|
||
}
|
||
w += cw;
|
||
}
|
||
s.len()
|
||
}
|
||
|
||
impl Default for App {
|
||
fn default() -> Self {
|
||
Self::new()
|
||
}
|
||
}
|