M0: compilable skeleton — Kigi 0.1.0 fork surgery
Hard fork of xai-org/grok-build (Apache-2.0) re-targeted as Kigi, an
unofficial Kimi Code CLI community build.
Rename & identity
- 72 xai-*/xai-grok-* crates -> kigi-* (explicit: xai-grok-pager-bin ->
kigi-bin [binary `kigi`], xai-grok-pager -> kigi-tui; rest mechanical);
ptyctl, ptyctl-cli, third_party/ unchanged; proto package
xai.grok.tools.v1 -> kigi.tools.v1
- Config home ~/.kigi (KIGI_SHARE_DIR override), env prefix GROK_* ->
KIGI_*, `kigi --version` carries the unofficial-community-build notice
- clap identity, help text, startup banner, prompt templates rebranded
(templates re-encrypted)
Deletions (PRD removal list #5/#6/#7/#9/#10)
- voice input (xai-grok-voice) and all TUI wiring
- telemetry: Mixpanel client, external OTel stream, Sentry, OTLP layers,
trace/GCS/S3 upload queues (kigi-file-utils halved), workspace upload
module & dc_log, heap-profile uploader, auth-diagnostics uploader,
session-analytics halves of feedback; local zero-egress observability
preserved in new kigi-log crate (unified log, --debug firehose,
subsystem file logs, opt-in instrumentation)
- announcements (crate, remote-settings fields, TUI surfaces)
- plugin marketplace (crate, sources/browse/CTA/extensions-modal tab);
direct plugin install/uninstall/update via kigi-agent git_install kept
- relay/gateway/assets endpoints and features (agent relay, headless
relay transport, gateway bridge, LeaderEnvUrls); leader IPC socket now
~/.kigi/leader.sock + KIGI_LEADER_SOCKET, no ws-url derivation
- functional types rehomed instead of deleted: PermissionMode ->
kigi-config-types, McpInitStrategy -> kigi-mcp, PrCreationSource ->
session signals, TerminalDiagnostics -> kigi-pager-render, agent_id ->
shell util
Endpoints
- kigi-env rewritten: single production KigiEndpoints {coding_api_base_url
https://api.kimi.com/coding/v1 (KIGI_CODE_BASE_URL), oauth_host
https://auth.kimi.com (KIGI_OAUTH_HOST), update_base_url (GitHub
Releases API), upgrade_page_url}; GrokBuildEnvironment enum deleted
Toolchain & workspace hygiene
- Rust 1.97.0 pinned; edition 2024; full cargo update; git2 hoisted to
workspace at 0.21 (Option->Result API migration), quick-xml 0.41
- Root Cargo.toml hand-maintained (PRD §8.1): version 0.1.0 inherited by
all members, members sorted, unused deps pruned
- cargo-deny advisories gate (deny.toml with documented transitive
exceptions); CI workflow (check/clippy/fmt/deny/test, macOS+Linux)
- cross-crate test seams re-gated behind `test-support` cargo feature;
insta snapshot baselines renamed to the kigi_tui prefix
- clippy --workspace --all-targets: zero warnings; fmt clean
Fixes surfaced by the port
- updater probe/installer divergence (bin/kigi vs bin/grok symlink set)
- idle model-metadata refresh dead under KIGI_CODE_BASE_URL override
(new is_effective_coding_endpoint_url, loopback+override aware)
- macOS symlinked-TMPDIR fixture canonicalization (foreign_sessions,
fast-worktree); RSS measurement tests serialized via serial_test
Docs & legal (Apache §4)
- NOTICE added (upstream attribution + change statement); THIRD-PARTY
notices sustained; kigi-tools ported-code notices extended; README,
CONTRIBUTING, SECURITY, AGENTS.md rewritten
Out of scope for M0 (tracked): Kimi auth/inference (M1), search/fetch,
command parity, config import (M2), Computer Hub excision & final
brand-token sweep (M2), distribution & self-update rewrite (M3).
This commit is contained in:
commit
d6c20fc13f
2612 files changed
+1353757
No files matched your search
@@ -0,0 +1,855 @@
|
||||
//! Plan surfaces: plan chip/preview, plan approval + feedback, and casual
|
||||
//! plan commenting (incl. the casual-commenting test fixture).
|
||||
use super::AgentView;
|
||||
#[cfg(test)]
|
||||
use super::{ActivePane, InputMode, test_fixtures};
|
||||
#[cfg(test)]
|
||||
use crate::actions::ActionRegistry;
|
||||
use crate::app::actions::Action;
|
||||
use crate::app::app_view::InputOutcome;
|
||||
use crate::views::file_search::line_viewer::LineViewerState;
|
||||
use crate::views::list_pane::ListItem;
|
||||
use crate::views::plan_approval_view::{PlanApprovalFocus, PlanComment, PlanReviewSource};
|
||||
use crate::views::prompt_widget::{EnterOutcome, PromptEvent};
|
||||
#[cfg(test)]
|
||||
use crossterm::event::KeyModifiers;
|
||||
use crossterm::event::{KeyCode, KeyEvent};
|
||||
impl AgentView {
|
||||
/// Resolve the absolute path to the plan file for this session.
|
||||
fn plan_file_path(&self) -> Option<std::path::PathBuf> {
|
||||
let session_id = self.session.session_id.as_ref()?;
|
||||
let cwd_str = self.session.cwd.to_string_lossy().into_owned();
|
||||
let encoded_cwd = urlencoding::encode(&cwd_str);
|
||||
Some(
|
||||
kigi_shell::util::kigi_home::kigi_home()
|
||||
.join("sessions")
|
||||
.join(encoded_cwd.as_ref())
|
||||
.join(session_id.0.as_ref())
|
||||
.join("plan.md"),
|
||||
)
|
||||
}
|
||||
/// Whether the current line viewer is showing a plan preview.
|
||||
pub(super) fn is_plan_viewer(&self) -> bool {
|
||||
self.line_viewer.as_ref().is_some_and(|v| {
|
||||
v.kind == crate::views::file_search::line_viewer::LineViewerKind::PlanPreview
|
||||
})
|
||||
}
|
||||
/// Whether the user is currently composing a comment via the prompt
|
||||
/// input inside the *casual* plan preview (the modal opened with no
|
||||
/// `plan_approval_view`). Mirrors the `pav.focus == Commenting`
|
||||
/// check used by the plan-approval path so the prompt/footer
|
||||
/// behaves identically across both modes.
|
||||
pub(super) fn is_casual_commenting(&self) -> bool {
|
||||
self.plan_approval_view.is_none()
|
||||
&& self.is_plan_viewer()
|
||||
&& self.casual_commenting_range.is_some()
|
||||
}
|
||||
/// Whether the prompt "auto" (LLM classifier mode) flag should render.
|
||||
/// Extracted for unit testing the precedence: auto shows only when the
|
||||
/// session is in auto mode and neither yolo (always-approve wins) nor plan
|
||||
/// is active.
|
||||
pub(super) fn auto_flag_visible(&self, effective_plan: bool) -> bool {
|
||||
self.session.is_auto() && !self.session.is_yolo() && !effective_plan
|
||||
}
|
||||
/// Whether plan content is available for preview.
|
||||
fn plan_preview_available(&self) -> bool {
|
||||
self.plan_body_for_preview().is_some()
|
||||
}
|
||||
/// Whether the "plan" status-bar chip should be rendered.
|
||||
///
|
||||
/// Visible while plan mode is active, or always when the user has set
|
||||
/// `show_plan_chip = true` in `pager.toml`. Hidden by default once the
|
||||
/// user exits plan mode.
|
||||
pub(super) fn should_show_plan_chip(
|
||||
&self,
|
||||
appearance: &crate::appearance::AppearanceConfig,
|
||||
) -> bool {
|
||||
(self.plan_mode_active || appearance.show_plan_chip) && self.plan_preview_available()
|
||||
}
|
||||
fn inline_plan_content(&self) -> Option<&str> {
|
||||
self.plan_approval_view
|
||||
.as_ref()
|
||||
.filter(|p| p.source == PlanReviewSource::Inline)
|
||||
.and_then(|p| p.plan_content.as_deref())
|
||||
.filter(|s| !s.trim().is_empty())
|
||||
}
|
||||
/// Resolve the plan body for the line-viewer preview.
|
||||
///
|
||||
/// Prefers content carried on the approval request (inline plan-creation or
|
||||
/// the shell-read file body), then falls back to the on-disk plan file.
|
||||
/// Request body first keeps file-backed previews working when the path
|
||||
/// resolution fails or the file disappears between intercept and open.
|
||||
fn plan_body_for_preview(&self) -> Option<String> {
|
||||
if let Some(content) = self
|
||||
.plan_approval_view
|
||||
.as_ref()
|
||||
.and_then(|p| p.plan_content.as_deref())
|
||||
.filter(|s| !s.trim().is_empty())
|
||||
{
|
||||
return Some(content.to_owned());
|
||||
}
|
||||
if let Some(content) = self
|
||||
.latest_inline_plan_content
|
||||
.as_deref()
|
||||
.filter(|s| !s.trim().is_empty())
|
||||
{
|
||||
return Some(content.to_owned());
|
||||
}
|
||||
self.plan_file_path()
|
||||
.and_then(|p| std::fs::read_to_string(p).ok())
|
||||
.filter(|s| !s.trim().is_empty())
|
||||
}
|
||||
/// Open the plan preview when content exists, or when plan approval is
|
||||
/// parked with an empty body (so the decision surface always pops).
|
||||
pub(crate) fn show_plan_preview_if_available(&mut self) {
|
||||
if self.plan_preview_available() || self.plan_approval_view.is_some() {
|
||||
self.show_plan_preview();
|
||||
}
|
||||
}
|
||||
/// Show the plan in the line viewer overlay or a "no plan" toast.
|
||||
///
|
||||
/// When plan approval is parked without a body, opens a placeholder
|
||||
/// preview so the user always sees a decision surface (a/s/q) instead of
|
||||
/// a dead "Waiting on plan approval" line with a no-op Tab:plan.
|
||||
pub fn show_plan_preview(&mut self) {
|
||||
let body = self.plan_body_for_preview();
|
||||
let approval_empty = self
|
||||
.plan_approval_view
|
||||
.as_ref()
|
||||
.is_some_and(|p| !p.has_plan);
|
||||
let Some(mut viewer) = (if let Some(content) = body {
|
||||
LineViewerState::open_markdown_content("plan.md", content, None)
|
||||
} else if approval_empty {
|
||||
LineViewerState::open_markdown_content(
|
||||
"plan.md",
|
||||
crate::views::plan_approval_view::EMPTY_PLAN_PLACEHOLDER.to_owned(),
|
||||
None,
|
||||
)
|
||||
} else if let Some(plan_path) = self.plan_file_path() {
|
||||
LineViewerState::open_markdown(&plan_path, None)
|
||||
} else {
|
||||
None
|
||||
}) else {
|
||||
self.show_toast("No plan written yet.");
|
||||
return;
|
||||
};
|
||||
viewer.kind = crate::views::file_search::line_viewer::LineViewerKind::PlanPreview;
|
||||
viewer.title_override = Some(if approval_empty {
|
||||
"plan.md (empty)".to_string()
|
||||
} else {
|
||||
"plan.md".to_string()
|
||||
});
|
||||
viewer.fullscreen = true;
|
||||
{
|
||||
let plan = viewer.plan_mut();
|
||||
plan.show_action_buttons = self.plan_approval_view.is_none();
|
||||
plan.feedback_active = self.plan_approval_view.is_some();
|
||||
}
|
||||
if let Some(ref pav) = self.plan_approval_view
|
||||
&& !pav.comments.is_empty()
|
||||
{
|
||||
viewer.rebuild_with_comments(&pav.comments);
|
||||
} else if !self.plan_comments.is_empty() {
|
||||
viewer.rebuild_with_comments(&self.plan_comments);
|
||||
}
|
||||
self.line_viewer = Some(viewer);
|
||||
}
|
||||
/// Test fixture: drive the agent into casual-commenting state
|
||||
/// (line viewer open in plan-preview mode + `casual_commenting_range`
|
||||
/// armed) so the `Event::Paste` plan-feedback arm at ~1539 is
|
||||
/// reachable from a unit test without spawning the real
|
||||
/// keystroke pipeline. Consolidates three field mutations into
|
||||
/// one helper so a future refactor of casual-commenting state
|
||||
/// only has to update this fixture rather than every test that
|
||||
/// reaches into the fields by name.
|
||||
#[cfg(test)]
|
||||
pub(crate) fn enter_casual_commenting_for_test(&mut self) {
|
||||
let mut viewer =
|
||||
crate::views::file_search::line_viewer::LineViewerState::open_markdown_content(
|
||||
"test.md",
|
||||
"hello\n".to_owned(),
|
||||
None,
|
||||
)
|
||||
.expect("fixture must open the line viewer");
|
||||
viewer.kind = crate::views::file_search::line_viewer::LineViewerKind::PlanPreview;
|
||||
self.line_viewer = Some(viewer);
|
||||
self.casual_commenting_range = Some(0..1);
|
||||
}
|
||||
pub(crate) fn approve_plan(&mut self) -> InputOutcome {
|
||||
let Some(mut pav) = self.plan_approval_view.take() else {
|
||||
return InputOutcome::Changed;
|
||||
};
|
||||
let review_comments = if !pav.comments.is_empty() {
|
||||
let formatted = pav.format_feedback(None);
|
||||
if formatted.trim().is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(format!(
|
||||
"The user approved the plan with the following review comments:\n\n{}",
|
||||
formatted
|
||||
))
|
||||
}
|
||||
} else {
|
||||
None
|
||||
};
|
||||
pav.send_approved();
|
||||
self.latest_inline_plan_content = None;
|
||||
self.plan_next_comment_id = pav.next_comment_id;
|
||||
self.prompt.restore(pav.stashed_prompt);
|
||||
self.line_viewer = None;
|
||||
self.casual_commenting_range = None;
|
||||
self.casual_editing_comment_id = None;
|
||||
{}
|
||||
if let Some(text) = review_comments {
|
||||
return InputOutcome::Action(Action::Interject {
|
||||
text,
|
||||
images: vec![],
|
||||
});
|
||||
}
|
||||
InputOutcome::Changed
|
||||
}
|
||||
pub(crate) fn abandon_plan(&mut self) -> InputOutcome {
|
||||
let Some(mut pav) = self.plan_approval_view.take() else {
|
||||
return InputOutcome::Changed;
|
||||
};
|
||||
pav.send_abandoned();
|
||||
self.plan_mode_pending = Some(false);
|
||||
self.latest_inline_plan_content = None;
|
||||
self.plan_next_comment_id = pav.next_comment_id;
|
||||
self.prompt.restore(pav.stashed_prompt);
|
||||
self.line_viewer = None;
|
||||
self.casual_commenting_range = None;
|
||||
self.casual_editing_comment_id = None;
|
||||
{}
|
||||
InputOutcome::Changed
|
||||
}
|
||||
fn send_plan_feedback(&mut self, feedback: Option<String>) -> InputOutcome {
|
||||
let Some(mut pav) = self.plan_approval_view.take() else {
|
||||
return InputOutcome::Changed;
|
||||
};
|
||||
let formatted = pav.format_feedback(feedback.as_deref());
|
||||
let to_send = if formatted.trim().is_empty() {
|
||||
feedback
|
||||
} else {
|
||||
Some(formatted)
|
||||
};
|
||||
if crate::app::minimal_mode_active()
|
||||
&& let Some(msg) = to_send.as_deref().map(str::trim).filter(|s| !s.is_empty())
|
||||
{
|
||||
self.scrollback
|
||||
.push_block(crate::scrollback::RenderBlock::user_prompt(msg.to_string()));
|
||||
}
|
||||
pav.send_cancelled(to_send);
|
||||
if pav.source == PlanReviewSource::Inline {
|
||||
self.latest_inline_plan_content = None;
|
||||
}
|
||||
self.plan_next_comment_id = pav.next_comment_id;
|
||||
self.prompt.restore(pav.stashed_prompt);
|
||||
self.line_viewer = None;
|
||||
self.prompt.textarea.cancel_undo_group();
|
||||
self.show_toast("Plan revision sent.");
|
||||
{}
|
||||
InputOutcome::Changed
|
||||
}
|
||||
pub(crate) fn reopen_plan_approval(&mut self) {
|
||||
if let Some(ref mut pav) = self.plan_approval_view {
|
||||
pav.stashed_prompt = self.prompt.stash();
|
||||
pav.focus = PlanApprovalFocus::Preview;
|
||||
}
|
||||
self.prompt.set_text("");
|
||||
self.show_plan_preview_if_available();
|
||||
if self.line_viewer.is_none() {
|
||||
if let Some(ref mut pav) = self.plan_approval_view {
|
||||
pav.focus = PlanApprovalFocus::Prompt;
|
||||
}
|
||||
} else if let Some(ref mut viewer) = self.line_viewer {
|
||||
viewer.plan_mut().feedback_active = true;
|
||||
}
|
||||
}
|
||||
/// Discard an in-progress comment draft: clear the prompt text and
|
||||
/// drop the selected line range + pending edit + stashed feedback.
|
||||
/// Used whenever focus leaves the prompt without an explicit save
|
||||
/// or cancel (e.g. Tab back to Preview, click into the modal).
|
||||
fn discard_in_progress_comment(&mut self) {
|
||||
if let Some(ref mut pav) = self.plan_approval_view {
|
||||
pav.commenting_range = None;
|
||||
pav.editing_comment_id = None;
|
||||
pav.stashed_feedback_prompt = None;
|
||||
}
|
||||
self.prompt.set_text("");
|
||||
}
|
||||
pub(super) fn handle_plan_feedback_key(&mut self, key: &KeyEvent) -> InputOutcome {
|
||||
let is_commenting = self
|
||||
.plan_approval_view
|
||||
.as_ref()
|
||||
.is_some_and(|pav| pav.focus == PlanApprovalFocus::Commenting);
|
||||
if key.code == KeyCode::Tab && key.modifiers.is_empty() {
|
||||
let focus = self.plan_approval_view.as_ref().map(|p| p.focus);
|
||||
match focus {
|
||||
Some(PlanApprovalFocus::Prompt) | Some(PlanApprovalFocus::Commenting) => {
|
||||
if self.line_viewer.is_none() {
|
||||
self.show_plan_preview_if_available();
|
||||
}
|
||||
if let Some(ref mut pav) = self.plan_approval_view {
|
||||
pav.focus = PlanApprovalFocus::Preview;
|
||||
}
|
||||
if let Some(ref mut viewer) = self.line_viewer {
|
||||
viewer.plan_mut().feedback_active = true;
|
||||
}
|
||||
}
|
||||
Some(PlanApprovalFocus::Preview) => {
|
||||
if let Some(ref mut pav) = self.plan_approval_view {
|
||||
pav.focus = PlanApprovalFocus::Prompt;
|
||||
}
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
if is_commenting {
|
||||
self.discard_in_progress_comment();
|
||||
}
|
||||
return InputOutcome::Changed;
|
||||
}
|
||||
if key.code == KeyCode::Esc {
|
||||
if self.prompt.file_search_visible() {
|
||||
self.prompt.file_search.clear_context();
|
||||
return InputOutcome::Changed;
|
||||
}
|
||||
if is_commenting {
|
||||
let stashed = if let Some(ref mut pav) = self.plan_approval_view {
|
||||
pav.focus = PlanApprovalFocus::Preview;
|
||||
pav.editing_comment_id = None;
|
||||
pav.commenting_range = None;
|
||||
pav.stashed_feedback_prompt.take()
|
||||
} else {
|
||||
None
|
||||
};
|
||||
if let Some(stashed) = stashed {
|
||||
self.prompt.restore(stashed);
|
||||
} else {
|
||||
self.prompt.set_text("");
|
||||
}
|
||||
return InputOutcome::Changed;
|
||||
}
|
||||
if let Some(ref mut pav) = self.plan_approval_view {
|
||||
pav.focus = PlanApprovalFocus::Preview;
|
||||
}
|
||||
return InputOutcome::Changed;
|
||||
}
|
||||
match self.prompt.route_enter(key) {
|
||||
EnterOutcome::NewlineInserted => return InputOutcome::Changed,
|
||||
EnterOutcome::Submit => {
|
||||
if is_commenting {
|
||||
return self.save_plan_comment();
|
||||
}
|
||||
let text = self.prompt.text().to_string();
|
||||
let has_comments = self
|
||||
.plan_approval_view
|
||||
.as_ref()
|
||||
.is_some_and(|pav| !pav.comments.is_empty());
|
||||
let prompt_focused = self
|
||||
.plan_approval_view
|
||||
.as_ref()
|
||||
.is_some_and(|pav| pav.focus == PlanApprovalFocus::Prompt);
|
||||
if prompt_focused {
|
||||
if text.trim().is_empty() && !has_comments {
|
||||
return self.approve_plan();
|
||||
}
|
||||
let freeform = if text.trim().is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(text)
|
||||
};
|
||||
return self.send_plan_feedback(freeform);
|
||||
}
|
||||
return InputOutcome::Changed;
|
||||
}
|
||||
EnterOutcome::PassThrough => {}
|
||||
}
|
||||
match self.prompt.handle_key(key) {
|
||||
PromptEvent::Edited => {
|
||||
if let Some(req) = self.prompt.pending_viewer_request.take() {
|
||||
self.open_line_viewer(&req.path, req.initial_range);
|
||||
}
|
||||
InputOutcome::Changed
|
||||
}
|
||||
PromptEvent::Ignored => InputOutcome::Changed,
|
||||
}
|
||||
}
|
||||
pub(super) fn enter_plan_commenting(&mut self) -> InputOutcome {
|
||||
let viewer = match self.line_viewer.as_mut() {
|
||||
Some(v) => v,
|
||||
None => return InputOutcome::Changed,
|
||||
};
|
||||
if let Some(vi) = viewer.list_state.selected_index() {
|
||||
let pi = viewer.list_state.to_physical(vi);
|
||||
if let Some(comment_id) = viewer.lines.get(pi).and_then(|item| item.comment_id())
|
||||
&& let Some(pav) = self.plan_approval_view.as_mut()
|
||||
&& let Some(comment) = pav.comments.iter().find(|c| c.id == comment_id)
|
||||
{
|
||||
let comment_text = comment.text.clone();
|
||||
let comment_range = comment.line_range.clone();
|
||||
pav.stashed_feedback_prompt = Some(self.prompt.stash());
|
||||
pav.editing_comment_id = Some(comment_id);
|
||||
pav.commenting_range = Some(comment_range);
|
||||
pav.focus = PlanApprovalFocus::Commenting;
|
||||
self.prompt.set_text(&comment_text);
|
||||
return InputOutcome::Changed;
|
||||
}
|
||||
}
|
||||
let range = viewer.selected_line_range();
|
||||
let Some(range) = range else {
|
||||
return InputOutcome::Changed;
|
||||
};
|
||||
if viewer.list_state.visual_mode {
|
||||
let start_vi = viewer.list_state.multi_range().map(|r| r.start);
|
||||
if let Some(start_vi) = start_vi {
|
||||
let start_pi = viewer.list_state.to_physical(start_vi);
|
||||
let start_id = viewer.lines.get(start_pi).map(|l| l.stable_id());
|
||||
viewer.list_state.exit_visual_mode();
|
||||
if let Some(id) = start_id {
|
||||
viewer.list_state.select_by_id(id);
|
||||
}
|
||||
} else {
|
||||
viewer.list_state.exit_visual_mode();
|
||||
}
|
||||
}
|
||||
if let Some(ref mut pav) = self.plan_approval_view {
|
||||
pav.stashed_feedback_prompt = Some(self.prompt.stash());
|
||||
pav.commenting_range = Some(range);
|
||||
pav.editing_comment_id = None;
|
||||
pav.focus = PlanApprovalFocus::Commenting;
|
||||
}
|
||||
self.prompt.set_text("");
|
||||
InputOutcome::Changed
|
||||
}
|
||||
fn save_plan_comment(&mut self) -> InputOutcome {
|
||||
let text = self.prompt.text().to_string();
|
||||
if text.trim().is_empty() {
|
||||
return InputOutcome::Changed;
|
||||
}
|
||||
let pav = match self.plan_approval_view.as_mut() {
|
||||
Some(pav) => pav,
|
||||
None => return InputOutcome::Changed,
|
||||
};
|
||||
let range = match pav.commenting_range.take() {
|
||||
Some(r) => r,
|
||||
None => return InputOutcome::Changed,
|
||||
};
|
||||
if let Some(edit_id) = pav.editing_comment_id.take() {
|
||||
if let Some(comment) = pav.comments.iter_mut().find(|c| c.id == edit_id) {
|
||||
comment.text = text;
|
||||
comment.line_range = range;
|
||||
}
|
||||
} else {
|
||||
let id = pav.next_comment_id;
|
||||
pav.next_comment_id += 1;
|
||||
pav.comments.push(PlanComment {
|
||||
id,
|
||||
line_range: range,
|
||||
text,
|
||||
});
|
||||
}
|
||||
pav.focus = PlanApprovalFocus::Preview;
|
||||
let comments = pav.comments.clone();
|
||||
if let Some(ref mut viewer) = self.line_viewer {
|
||||
viewer.rebuild_with_comments(&comments);
|
||||
}
|
||||
if let Some(stashed) = pav.stashed_feedback_prompt.take() {
|
||||
self.prompt.restore(stashed);
|
||||
} else {
|
||||
self.prompt.set_text("");
|
||||
}
|
||||
InputOutcome::Changed
|
||||
}
|
||||
pub(super) fn delete_plan_comment_at_cursor(&mut self) -> InputOutcome {
|
||||
let viewer = match self.line_viewer.as_ref() {
|
||||
Some(v) => v,
|
||||
None => return InputOutcome::Changed,
|
||||
};
|
||||
let vi = match viewer.list_state.selected_index() {
|
||||
Some(vi) => vi,
|
||||
None => return InputOutcome::Changed,
|
||||
};
|
||||
let pi = viewer.list_state.to_physical(vi);
|
||||
let comment_id = match viewer.lines.get(pi).and_then(|item| item.comment_id()) {
|
||||
Some(id) => id,
|
||||
None => return InputOutcome::Changed,
|
||||
};
|
||||
if let Some(ref mut pav) = self.plan_approval_view {
|
||||
pav.comments.retain(|c| c.id != comment_id);
|
||||
let comments = pav.comments.clone();
|
||||
if let Some(ref mut viewer) = self.line_viewer {
|
||||
viewer.rebuild_with_comments(&comments);
|
||||
}
|
||||
}
|
||||
InputOutcome::Changed
|
||||
}
|
||||
/// Enter casual commenting mode from the plan preview.
|
||||
///
|
||||
/// If the cursor is on a comment line, enter edit mode for that comment.
|
||||
/// If the cursor is on a source line, capture the line range and enter
|
||||
/// new-comment mode.
|
||||
pub(super) fn enter_casual_plan_commenting(&mut self) -> InputOutcome {
|
||||
let viewer = match self.line_viewer.as_mut() {
|
||||
Some(v) => v,
|
||||
None => return InputOutcome::Changed,
|
||||
};
|
||||
if let Some(vi) = viewer.list_state.selected_index() {
|
||||
let pi = viewer.list_state.to_physical(vi);
|
||||
if let Some(comment_id) = viewer.lines.get(pi).and_then(|item| item.comment_id())
|
||||
&& let Some(comment) = self.plan_comments.iter().find(|c| c.id == comment_id)
|
||||
{
|
||||
let comment_text = comment.text.clone();
|
||||
let comment_range = comment.line_range.clone();
|
||||
if self.casual_stashed_prompt.is_none() {
|
||||
self.casual_stashed_prompt = Some(self.prompt.stash());
|
||||
}
|
||||
self.casual_editing_comment_id = Some(comment_id);
|
||||
self.casual_commenting_range = Some(comment_range);
|
||||
self.prompt.set_text(&comment_text);
|
||||
return InputOutcome::Changed;
|
||||
}
|
||||
}
|
||||
let range = viewer.selected_line_range();
|
||||
let Some(range) = range else {
|
||||
return InputOutcome::Changed;
|
||||
};
|
||||
if viewer.list_state.visual_mode {
|
||||
let start_vi = viewer.list_state.multi_range().map(|r| r.start);
|
||||
if let Some(start_vi) = start_vi {
|
||||
let start_pi = viewer.list_state.to_physical(start_vi);
|
||||
let start_id = viewer.lines.get(start_pi).map(|l| l.stable_id());
|
||||
viewer.list_state.exit_visual_mode();
|
||||
if let Some(id) = start_id {
|
||||
viewer.list_state.select_by_id(id);
|
||||
}
|
||||
} else {
|
||||
viewer.list_state.exit_visual_mode();
|
||||
}
|
||||
}
|
||||
if self.casual_stashed_prompt.is_none() {
|
||||
self.casual_stashed_prompt = Some(self.prompt.stash());
|
||||
}
|
||||
self.casual_commenting_range = Some(range);
|
||||
self.casual_editing_comment_id = None;
|
||||
self.prompt.set_text("");
|
||||
InputOutcome::Changed
|
||||
}
|
||||
/// Save the current casual comment (new or edited) and rebuild the viewer.
|
||||
pub(super) fn save_casual_plan_comment(&mut self) -> InputOutcome {
|
||||
let text = self.prompt.text().to_owned();
|
||||
if text.trim().is_empty() {
|
||||
return self.cancel_casual_plan_commenting();
|
||||
}
|
||||
let range = match self.casual_commenting_range.take() {
|
||||
Some(r) => r,
|
||||
None => return self.cancel_casual_plan_commenting(),
|
||||
};
|
||||
if let Some(edit_id) = self.casual_editing_comment_id.take() {
|
||||
if let Some(comment) = self.plan_comments.iter_mut().find(|c| c.id == edit_id) {
|
||||
comment.text = text;
|
||||
comment.line_range = range;
|
||||
}
|
||||
} else {
|
||||
let id = self.plan_next_comment_id;
|
||||
self.plan_next_comment_id += 1;
|
||||
self.plan_comments.push(PlanComment {
|
||||
id,
|
||||
line_range: range,
|
||||
text,
|
||||
});
|
||||
}
|
||||
if let Some(stashed) = self.casual_stashed_prompt.take() {
|
||||
self.prompt.restore(stashed);
|
||||
} else {
|
||||
self.prompt.set_text("");
|
||||
}
|
||||
let comments = self.plan_comments.clone();
|
||||
if let Some(ref mut viewer) = self.line_viewer {
|
||||
viewer.rebuild_with_comments(&comments);
|
||||
}
|
||||
InputOutcome::Changed
|
||||
}
|
||||
/// Cancel casual plan commenting without saving.
|
||||
pub(super) fn cancel_casual_plan_commenting(&mut self) -> InputOutcome {
|
||||
self.casual_commenting_range = None;
|
||||
self.casual_editing_comment_id = None;
|
||||
if let Some(stashed) = self.casual_stashed_prompt.take() {
|
||||
self.prompt.restore(stashed);
|
||||
} else {
|
||||
self.prompt.set_text("");
|
||||
}
|
||||
InputOutcome::Changed
|
||||
}
|
||||
/// Key handler used while the user is composing a casual plan
|
||||
/// comment via the prompt input. Mirrors `handle_plan_feedback_key`
|
||||
/// (which serves the plan-approval Commenting focus) so the UX is
|
||||
/// identical: Enter saves, Esc cancels, Tab cancels back to the
|
||||
/// modal, and everything else routes to the prompt textarea.
|
||||
pub(super) fn handle_casual_plan_feedback_key(&mut self, key: &KeyEvent) -> InputOutcome {
|
||||
if key.code == KeyCode::Esc {
|
||||
if self.prompt.file_search_visible() {
|
||||
self.prompt.file_search.clear_context();
|
||||
return InputOutcome::Changed;
|
||||
}
|
||||
return self.cancel_casual_plan_commenting();
|
||||
}
|
||||
match self.prompt.route_enter(key) {
|
||||
EnterOutcome::NewlineInserted => return InputOutcome::Changed,
|
||||
EnterOutcome::Submit => return self.save_casual_plan_comment(),
|
||||
EnterOutcome::PassThrough => {}
|
||||
}
|
||||
if key.code == KeyCode::Tab && key.modifiers.is_empty() {
|
||||
return self.cancel_casual_plan_commenting();
|
||||
}
|
||||
match self.prompt.handle_key(key) {
|
||||
PromptEvent::Edited => {
|
||||
if let Some(req) = self.prompt.pending_viewer_request.take() {
|
||||
self.open_line_viewer(&req.path, req.initial_range);
|
||||
}
|
||||
InputOutcome::Changed
|
||||
}
|
||||
PromptEvent::Ignored => InputOutcome::Changed,
|
||||
}
|
||||
}
|
||||
/// Delete the casual comment under the cursor in the plan preview.
|
||||
pub(super) fn delete_casual_plan_comment_at_cursor(&mut self) -> InputOutcome {
|
||||
let viewer = match self.line_viewer.as_ref() {
|
||||
Some(v) => v,
|
||||
None => return InputOutcome::Unchanged,
|
||||
};
|
||||
let vi = match viewer.list_state.selected_index() {
|
||||
Some(vi) => vi,
|
||||
None => return InputOutcome::Unchanged,
|
||||
};
|
||||
let pi = viewer.list_state.to_physical(vi);
|
||||
let comment_id = match viewer.lines.get(pi).and_then(|item| item.comment_id()) {
|
||||
Some(id) => id,
|
||||
None => return InputOutcome::Unchanged,
|
||||
};
|
||||
self.plan_comments.retain(|c| c.id != comment_id);
|
||||
let comments = self.plan_comments.clone();
|
||||
if let Some(ref mut viewer) = self.line_viewer {
|
||||
viewer.rebuild_with_comments(&comments);
|
||||
}
|
||||
InputOutcome::Changed
|
||||
}
|
||||
pub(super) fn send_casual_plan_comments(&mut self) -> InputOutcome {
|
||||
if self.plan_comments.is_empty() {
|
||||
self.show_toast("No comments to send.");
|
||||
return InputOutcome::Changed;
|
||||
}
|
||||
let plan_content = self.inline_plan_content().map(str::to_owned).or_else(|| {
|
||||
let path = self.plan_file_path()?;
|
||||
std::fs::read_to_string(path).ok()
|
||||
});
|
||||
let body = crate::views::plan_approval_view::format_plan_comments(
|
||||
&self.plan_comments,
|
||||
plan_content.as_deref(),
|
||||
);
|
||||
let text = format!("Plan feedback:\n\n{body}");
|
||||
self.plan_comments.clear();
|
||||
self.plan_next_comment_id = 0;
|
||||
self.cancel_line_viewer();
|
||||
self.show_toast("Plan feedback sent.");
|
||||
InputOutcome::Action(Action::SendPrompt(text))
|
||||
}
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod prompt_flag_tests {
|
||||
use super::test_fixtures::make_agent;
|
||||
/// The prompt "auto" (classifier) mode flag shows only when the session is
|
||||
/// in Auto and neither yolo (always-approve wins) nor plan is active.
|
||||
#[test]
|
||||
fn auto_flag_visible_precedence() {
|
||||
let mut agent = make_agent();
|
||||
assert!(!agent.auto_flag_visible(false));
|
||||
agent.session.auto_mode = true;
|
||||
assert!(agent.auto_flag_visible(false));
|
||||
assert!(!agent.auto_flag_visible(true));
|
||||
agent.session.yolo_mode = true;
|
||||
assert!(!agent.auto_flag_visible(false));
|
||||
agent.session.yolo_mode = false;
|
||||
assert!(agent.auto_flag_visible(false));
|
||||
}
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod plan_chip_tests {
|
||||
use super::*;
|
||||
use crate::acp::model_state::ModelState;
|
||||
use crate::app::agent::{AgentId, AgentSession, AgentState};
|
||||
use crate::appearance::AppearanceConfig;
|
||||
use crate::scrollback::state::ScrollbackState;
|
||||
fn make_agent() -> AgentView {
|
||||
let (tx, _rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
AgentView::new(
|
||||
AgentSession {
|
||||
id: AgentId(0),
|
||||
acp_tx: tx,
|
||||
session_id: None,
|
||||
models: ModelState::default(),
|
||||
state: AgentState::Idle,
|
||||
tracker: crate::acp::tracker::AcpUpdateTracker::new(),
|
||||
cwd: std::path::PathBuf::from("/tmp"),
|
||||
is_worktree: false,
|
||||
forked_from: None,
|
||||
pending_prompts: std::collections::VecDeque::new(),
|
||||
next_queue_id: 0,
|
||||
yolo_mode: false,
|
||||
auto_mode: false,
|
||||
prompt_history: Vec::new(),
|
||||
prompt_history_loading: false,
|
||||
loading_replay: false,
|
||||
restore_degree: None,
|
||||
rate_limited: false,
|
||||
model_incompatible: false,
|
||||
credit_limit_blocked: false,
|
||||
free_usage_blocked: false,
|
||||
available_commands: Vec::new(),
|
||||
available_commands_generation: 0,
|
||||
available_tools: None,
|
||||
model_switch_pending: false,
|
||||
user_model_preference: None,
|
||||
deferred_model_switch: None,
|
||||
bg_tasks: std::collections::BTreeMap::new(),
|
||||
bg_tool_call_to_task: std::collections::HashMap::new(),
|
||||
scheduled_tasks: std::collections::HashMap::new(),
|
||||
in_flight_prompt: None,
|
||||
current_prompt_id: None,
|
||||
created_via_new: false,
|
||||
},
|
||||
ScrollbackState::new(),
|
||||
)
|
||||
}
|
||||
#[test]
|
||||
fn plan_chip_hidden_after_exit_by_default() {
|
||||
let mut agent = make_agent();
|
||||
agent.plan_mode_active = false;
|
||||
let appearance = AppearanceConfig::default();
|
||||
assert!(!appearance.show_plan_chip);
|
||||
assert!(!agent.should_show_plan_chip(&appearance));
|
||||
}
|
||||
#[test]
|
||||
fn plan_chip_visible_while_plan_mode_active() {
|
||||
let mut agent = make_agent();
|
||||
agent.plan_mode_active = true;
|
||||
let appearance = AppearanceConfig::default();
|
||||
assert!(!agent.should_show_plan_chip(&appearance));
|
||||
}
|
||||
#[test]
|
||||
fn plan_chip_visible_when_config_overrides() {
|
||||
let mut agent = make_agent();
|
||||
agent.plan_mode_active = false;
|
||||
let appearance = AppearanceConfig {
|
||||
show_plan_chip: true,
|
||||
..Default::default()
|
||||
};
|
||||
assert!(!agent.should_show_plan_chip(&appearance));
|
||||
}
|
||||
#[test]
|
||||
fn set_input_mode_vim_empty_prompt_switches_to_scrollback_and_j_selects_next() {
|
||||
crate::appearance::cache::set_simple_mode(true);
|
||||
let mut agent = make_agent();
|
||||
agent.vim_mode = true;
|
||||
agent.set_active_pane(ActivePane::Prompt, true);
|
||||
agent.set_input_mode(InputMode::Vim);
|
||||
assert_eq!(agent.active_pane, ActivePane::Scrollback);
|
||||
assert!(!agent.is_simple_mode());
|
||||
let registry = ActionRegistry::defaults();
|
||||
let j = KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE);
|
||||
let outcome = agent.handle_scrollback_key(&j, ®istry);
|
||||
assert!(matches!(outcome, InputOutcome::Action(Action::SelectNext)));
|
||||
}
|
||||
#[test]
|
||||
fn set_input_mode_vim_nonempty_prompt_keeps_pane() {
|
||||
let mut agent = make_agent();
|
||||
agent.set_active_pane(ActivePane::Prompt, true);
|
||||
agent.prompt.set_text("draft");
|
||||
agent.set_input_mode(InputMode::Vim);
|
||||
assert_eq!(agent.active_pane, ActivePane::Prompt);
|
||||
}
|
||||
#[test]
|
||||
fn set_input_mode_simple_from_scrollback_leaves_pane_unchanged() {
|
||||
let mut agent = make_agent();
|
||||
agent.vim_mode = true;
|
||||
agent.set_active_pane(ActivePane::Scrollback, true);
|
||||
agent.set_input_mode(InputMode::Simple);
|
||||
assert_eq!(agent.active_pane, ActivePane::Scrollback);
|
||||
assert!(agent.is_simple_mode());
|
||||
let registry = ActionRegistry::defaults();
|
||||
let x = KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE);
|
||||
let outcome = agent.handle_scrollback_key(&x, ®istry);
|
||||
assert_eq!(agent.active_pane, ActivePane::Scrollback);
|
||||
assert!(matches!(outcome, InputOutcome::Unchanged));
|
||||
}
|
||||
#[test]
|
||||
fn new_agent_respects_persisted_simple_mode_for_mode_and_pane() {
|
||||
crate::appearance::cache::set_simple_mode(true);
|
||||
let a1 = make_agent();
|
||||
assert!(a1.is_simple_mode());
|
||||
assert_eq!(a1.active_pane, ActivePane::Prompt);
|
||||
crate::appearance::cache::set_simple_mode(false);
|
||||
let a2 = make_agent();
|
||||
assert!(!a2.is_simple_mode());
|
||||
assert_eq!(a2.active_pane, ActivePane::Scrollback);
|
||||
}
|
||||
#[test]
|
||||
fn set_input_mode_reconciles_pane_orthogonal_to_active_modal_field() {
|
||||
let mut agent = make_agent();
|
||||
agent.set_active_pane(ActivePane::Prompt, true);
|
||||
agent.active_modal = None;
|
||||
agent.set_input_mode(InputMode::Vim);
|
||||
assert_eq!(agent.active_pane, ActivePane::Scrollback);
|
||||
assert!(agent.active_modal.is_none());
|
||||
}
|
||||
#[test]
|
||||
fn scrollback_j_with_vim_mode_off_forwards_to_prompt() {
|
||||
crate::appearance::cache::set_vim_mode(false);
|
||||
let mut agent = make_agent();
|
||||
agent.vim_mode = false;
|
||||
agent.set_active_pane(ActivePane::Scrollback, true);
|
||||
let registry = ActionRegistry::defaults();
|
||||
let j = KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE);
|
||||
let outcome = agent.handle_scrollback_key(&j, ®istry);
|
||||
assert!(
|
||||
matches!(
|
||||
outcome,
|
||||
InputOutcome::ActionThenForward(Action::FocusPrompt)
|
||||
),
|
||||
"vim-off: bare 'j' in scrollback must forward to prompt; got {outcome:?}"
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
fn scrollback_j_with_vim_mode_on_selects_next() {
|
||||
crate::appearance::cache::set_vim_mode(true);
|
||||
let mut agent = make_agent();
|
||||
agent.vim_mode = true;
|
||||
agent.set_active_pane(ActivePane::Scrollback, true);
|
||||
let registry = ActionRegistry::defaults();
|
||||
let j = KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE);
|
||||
let outcome = agent.handle_scrollback_key(&j, ®istry);
|
||||
assert!(
|
||||
matches!(outcome, InputOutcome::Action(Action::SelectNext)),
|
||||
"vim-on: bare 'j' in scrollback must dispatch SelectNext; got {outcome:?}"
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
fn scrollback_arrow_down_works_in_both_modes() {
|
||||
let registry = ActionRegistry::defaults();
|
||||
let down = KeyEvent::new(KeyCode::Down, KeyModifiers::NONE);
|
||||
let mut a_off = make_agent();
|
||||
a_off.vim_mode = false;
|
||||
a_off.set_active_pane(ActivePane::Scrollback, true);
|
||||
assert!(matches!(
|
||||
a_off.handle_scrollback_key(&down, ®istry),
|
||||
InputOutcome::Action(Action::SelectNext)
|
||||
));
|
||||
let mut a_on = make_agent();
|
||||
a_on.vim_mode = true;
|
||||
a_on.set_active_pane(ActivePane::Scrollback, true);
|
||||
assert!(matches!(
|
||||
a_on.handle_scrollback_key(&down, ®istry),
|
||||
InputOutcome::Action(Action::SelectNext)
|
||||
));
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user