Порівняти коміти

..
Автор SHA1 Повідомлення Дата
l0ng-ai bef07d5a98 feat(vcs): open a push dialog file's diff in its own window
The push dialog showed a file's diff only in a split inside the small
modal dialog. Double-click or Enter on a file now opens the diff in a
separate diff window (Show Diff in New Window), as IDEA's push dialog does;
closing it returns to the dialog with its state. Single selection still
shows the diff in the dialog's split.
2026-11-19 18:28:17 +08:00
118 змінених файлів з 940 додано та 6528 видалено

No files matched your search

-32
Переглянути файл
@@ -256,38 +256,6 @@ impl AgentCatalogs {
.cloned()
}
pub(super) async fn load_levels(
self: &Arc<Self>,
shared: &Arc<Shared>,
provider: &str,
model: &str,
) -> Result<Vec<AgentConfigOption>, String> {
if let Some(levels) = self.levels(shared, provider, model) {
return Ok(levels);
}
let unavailable = || "The agent did not report settings for the selected model".to_owned();
let spec = shared.spec(provider).ok_or_else(unavailable)?;
let (_, flight) = self.request(shared, spec, false, Some(model));
if let Some(mut ready) = flight {
while !*ready.borrow_and_update() {
if ready.changed().await.is_err() {
break;
}
}
}
self.levels(shared, provider, model).ok_or_else(|| {
let state = self.state.lock();
state
.entries
.get(&Self::key(shared, provider))
.and_then(|entry| {
entry.model_failures.get(model).map(|failure| &failure.error).or(entry.error.as_ref())
})
.cloned()
.unwrap_or_else(unavailable)
})
}
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
let key = Self::key(shared, provider);
let mut state = self.state.lock();
+25 -193
Переглянути файл
@@ -323,36 +323,6 @@ async fn discovered_model_can_be_selected_while_the_session_is_not_running() {
switch_chat_model(ChatSwitch::Idle).await;
}
#[tokio::test]
async fn discovered_model_effort_is_discovered_persisted_and_applied_before_the_first_reply() {
switch_chat_model(ChatSwitch::Uncached).await;
}
#[tokio::test]
async fn discovered_model_with_no_effort_can_be_selected() {
switch_chat_model(ChatSwitch::NoEffort).await;
}
#[tokio::test]
async fn discovered_model_settings_failure_leaves_the_chat_unchanged() {
switch_chat_model(ChatSwitch::DiscoveryFails).await;
}
#[tokio::test]
async fn discovered_model_withdrawn_effort_prevents_sending() {
switch_chat_model(ChatSwitch::EffortUnavailable).await;
}
#[tokio::test]
async fn discovered_model_rejected_effort_prevents_sending() {
switch_chat_model(ChatSwitch::EffortRejected).await;
}
#[tokio::test]
async fn discovered_model_lookup_does_not_overwrite_a_newer_selection() {
switch_chat_model(ChatSwitch::Superseded).await;
}
#[derive(Clone, Copy)]
enum ChatSwitch {
Live,
@@ -360,12 +330,6 @@ enum ChatSwitch {
ResumeFails,
Unavailable,
Idle,
Uncached,
NoEffort,
DiscoveryFails,
EffortUnavailable,
EffortRejected,
Superseded,
}
async fn switch_chat_model(scenario: ChatSwitch) {
@@ -412,21 +376,7 @@ async fn switch_chat_model(scenario: ChatSwitch) {
}
let before_entries = serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap();
let before_config = manager.task(&task.id).unwrap().state.lock().task.config.clone();
let offline = matches!(scenario, ChatSwitch::Idle | ChatSwitch::Uncached | ChatSwitch::Superseded);
let missing_settings = matches!(
scenario,
ChatSwitch::Uncached | ChatSwitch::NoEffort | ChatSwitch::DiscoveryFails | ChatSwitch::Superseded
);
let no_effort = matches!(scenario, ChatSwitch::NoEffort);
let effort_error = match scenario {
ChatSwitch::EffortUnavailable => Some("no longer offers effort value thorough"),
ChatSwitch::EffortRejected => Some("effort rejected by the agent"),
_ => None,
};
let choose_effort = matches!(scenario, ChatSwitch::Uncached) || effort_error.is_some();
let (catalog_models, catalog_effort): (&[&str], &[&str]) =
if missing_settings { (&["old", "new"], &["low", "high"]) } else { (&["new", "old"], &["quick", "thorough"]) };
if offline {
if matches!(scenario, ChatSwitch::Idle) {
manager.shutdown();
manager = make_manager(tmp.path(), Arc::default(), &harness);
}
@@ -435,122 +385,41 @@ async fn switch_chat_model(scenario: ChatSwitch) {
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
let next = harness.next().await;
assert_eq!((next.launch, next.method.as_str()), (1, "session/new"));
next.reply.send(Ok(response(catalog_models, catalog_effort))).unwrap();
let catalog = completed(&mut events).await;
assert_eq!(model_values(&catalog), catalog_models);
if missing_settings {
assert!(!catalog.thought_levels.contains_key("new"));
}
next.reply.send(Ok(response(&["new", "old"], &["catalog-only"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["new", "old"]);
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
let live = matches!(scenario, ChatSwitch::Live);
let resumed_launch = if missing_settings { 3 } else { 2 };
let offline = matches!(scenario, ChatSwitch::Idle);
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
{
let switching = manager.set_config(&task.id, "model", "new".into());
tokio::pin!(switching);
if !offline {
let next = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
if live {
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
} else {
next.reply.send(Err("not in this process's model list".into())).unwrap();
}
}
if missing_settings {
let discovery = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((discovery.launch, discovery.method.as_str()), (2, "session/new"));
discovery.reply.send(Ok(response(catalog_models, catalog_effort))).unwrap();
let set = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!(set.params, json!({"sessionId": "discovery-only", "configId": "model", "value": "new"}));
assert_eq!(set.method, "session/set_config_option");
assert!(
manager
.prompt(&task.id, AgentPrompt { text: "too early".into(), ..Default::default() }, false)
.await
.is_err()
);
if matches!(scenario, ChatSwitch::DiscoveryFails) {
set.reply.send(Err("Sign in required".into())).unwrap();
let error = switching.await.unwrap_err().to_string();
assert!(error.contains("Sign in required"), "{error}");
assert_eq!(manager.subscribe(Arc::new(|_| {})).remove(0).config, before_config);
assert!(harness.pending.try_recv().is_err());
manager.shutdown();
return;
}
if matches!(scenario, ChatSwitch::Superseded) {
manager.set_config(&task.id, "model", "old".into()).await.unwrap();
set.reply.send(Ok(response(&["new", "old"], &["quick", "thorough"]))).unwrap();
switching.await.unwrap();
let task = manager.subscribe(Arc::new(|_| {})).remove(0);
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
assert_eq!(task.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("low"));
assert!(harness.pending.try_recv().is_err());
manager.shutdown();
return;
}
let levels: &[&str] = if no_effort { &[] } else { &["quick", "thorough"] };
set.reply.send(Ok(response(&["new", "old"], levels))).unwrap();
}
tokio::select! {
result = &mut switching => result.unwrap(),
request = harness.next() => panic!("selection must not reopen the chat or send: {request:?}"),
let switching = manager.set_config(&task.id, "model", "new".into());
tokio::pin!(switching);
if !offline {
let next = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
if live {
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
} else {
next.reply.send(Err("not in this process's model list".into())).unwrap();
}
}
// A fallback selection settles without waiting for a new process.
tokio::select! {
result = &mut switching => result.unwrap(),
request = harness.next() => panic!("selection must not open another session: {request:?}"),
}
assert_eq!(serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap(), before_entries);
if matches!(scenario, ChatSwitch::Uncached) {
let update = tokio::time::timeout(Duration::from_secs(5), async {
loop {
if let AgentEvent::Task { task: update } = events.recv().await.unwrap()
&& update.id == task.id
{
break update;
}
}
})
.await
.unwrap();
let effort = update.config.iter().find(|o| o.id == "effort").unwrap();
assert_eq!(effort.values.iter().map(|v| v.value.as_str()).collect::<Vec<_>>(), ["quick", "thorough"]);
}
let snapshot = |manager: &AgentManager| manager.subscribe(Arc::new(|_| {})).remove(0);
let current = snapshot(&manager);
assert_eq!(current.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("new"));
assert_eq!(current.model.as_deref(), Some(if live { "new" } else { "old" }));
let effort =
|task: &crate::AgentTask| task.config.iter().find(|o| o.id == "effort").and_then(|o| o.current.clone());
assert_eq!(
effort(&current).as_deref(),
if live {
Some("session-only")
} else if no_effort {
None
} else {
Some("quick")
},
"the new model's effort must be available before sending"
);
if choose_effort {
assert!(manager.set_config(&task.id, "effort", "high".into()).await.is_err());
manager.set_config(&task.id, "effort", "thorough".into()).await.unwrap();
assert_eq!(effort(&snapshot(&manager)).as_deref(), Some("thorough"));
if matches!(scenario, ChatSwitch::Uncached) {
manager.shutdown();
manager = make_manager(tmp.path(), Arc::default(), &harness);
let restored = snapshot(&manager);
assert_eq!(restored.id, task.id);
assert_eq!(effort(&restored).as_deref(), Some("thorough"));
}
}
manager.prompt(&task.id, AgentPrompt { text: "next".into(), ..Default::default() }, false).await.unwrap();
if !live {
let load = harness.next().await;
assert_eq!((load.launch, load.method.as_str()), (resumed_launch, "session/load"));
assert_eq!((load.launch, load.method.as_str()), (2, "session/load"));
assert_eq!(load.params["sessionId"], "saved-chat");
load.notifications
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
@@ -578,7 +447,6 @@ async fn switch_chat_model(scenario: ChatSwitch) {
let task = snapshot(&manager);
assert_eq!(task.model.as_deref(), Some("old"));
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
assert_eq!(effort(&task).as_deref(), Some("low"));
let expected = if load_fails { "cannot resume saved-chat" } else { "does not offer model new" };
assert!(task.error.as_deref().unwrap().contains(expected), "{:?}", task.error);
assert!(harness.pending.try_recv().is_err(), "must not send on the previous model or create a session");
@@ -604,60 +472,24 @@ async fn switch_chat_model(scenario: ChatSwitch) {
return;
}
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_config_option"));
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_config_option"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
let levels: &[&str] = match scenario {
ChatSwitch::NoEffort => &[],
ChatSwitch::EffortUnavailable => &["session-only", "quick"],
_ if choose_effort => &["session-only", "thorough"],
_ => &["session-only"],
};
set.reply.send(Ok(response(&["new", "old"], levels))).unwrap();
set.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_mode"));
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_mode"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
set.reply.send(Ok(json!({}))).unwrap();
if choose_effort && !matches!(scenario, ChatSwitch::EffortUnavailable) {
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_config_option"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "effort", "value": "thorough"}));
let reply = if effort_error.is_some() {
Err("effort rejected by the agent".into())
} else {
Ok(response(&["new", "old"], &["thorough", "session-only"]))
};
set.reply.send(reply).unwrap();
}
if let Some(expected) = effort_error {
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
let current = snapshot(&manager);
assert_eq!(current.model.as_deref(), Some("old"));
assert_eq!(effort(&current).as_deref(), Some("low"));
assert!(current.error.as_deref().unwrap().contains(expected), "{:?}", current.error);
assert!(harness.pending.try_recv().is_err(), "must not send using a fallback effort");
manager.shutdown();
return;
}
}
let next = harness.next().await;
assert_eq!(
(next.launch, next.method.as_str(), &next.params["sessionId"]),
(if live { 0 } else { resumed_launch }, "session/prompt", &json!("saved-chat"))
(if live { 0 } else { 2 }, "session/prompt", &json!("saved-chat"))
);
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
let current = snapshot(&manager);
assert_eq!(current.model.as_deref(), Some("new"));
assert_eq!(
effort(&current).as_deref(),
if choose_effort {
Some("thorough")
} else if no_effort {
None
} else {
Some("session-only")
}
);
assert_eq!(current.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("session-only"));
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
manager.shutdown();
}
+112 -309
Переглянути файл
@@ -357,11 +357,9 @@ struct TaskFile {
/// Settings the user chose, re-applied to every new or reloaded session.
#[serde(default)]
wanted: Vec<AgentConfigChoice>,
/// Pending model option id in task files saved before pending settings were stored separately.
#[serde(default, skip_serializing)]
pending_model: Option<String>,
/// Option id of a discovered model in `wanted` that still needs a same-session reload.
#[serde(default, skip_serializing_if = "Option::is_none")]
pending_switch: Option<PendingModel>,
pending_model: Option<String>,
/// In the project's own checkout: files already changed when the task started.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
before: BTreeMap<String, worktree::Stamp>,
@@ -386,26 +384,6 @@ struct TaskFile {
title_renamed: bool,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
struct PendingModel {
model: AgentConfigChoice,
candidate: Option<AgentConfigValue>,
options: Vec<AgentConfigOption>,
choices: Vec<AgentConfigChoice>,
}
impl PendingModel {
fn apply(&self, wanted: &mut Vec<AgentConfigChoice>, confirmed: &[AgentConfigOption]) {
wanted.retain(|choice| {
choice.id != self.model.id
&& !self.options.iter().any(|o| o.id == choice.id)
&& !confirmed.iter().any(|o| o.id == choice.id && config::is_per_model_option(o))
});
wanted.push(self.model.clone());
wanted.extend(self.choices.iter().cloned());
}
}
/// The changed files of a checkout, stamped.
type Snapshot = BTreeMap<String, worktree::Stamp>;
@@ -414,9 +392,8 @@ struct TaskState {
session_id: Option<String>,
conversation: Conversation,
wanted: Vec<AgentConfigChoice>,
pending_model: Option<PendingModel>,
pending_model: Option<String>,
model_choice: u64,
discovering_model: Option<u64>,
before: Arc<BTreeMap<String, worktree::Stamp>>,
saved: Option<String>,
/// See `TaskFile::touched`.
@@ -438,43 +415,23 @@ struct TaskState {
}
impl TaskState {
fn pending_model(&self) -> Option<&AgentConfigChoice> {
let id = self.pending_model.as_deref()?;
self.wanted.iter().find(|c| c.id == id)
}
fn snapshot(&self) -> AgentTask {
let mut task = self.task.clone();
if let Some(pending) = &self.pending_model
&& let Some(model) = task.config.iter_mut().find(|o| o.id == pending.model.id)
if let Some(choice) = self.pending_model()
&& let Some(model) = task.config.iter_mut().find(|o| o.id == choice.id)
{
model.current = Some(pending.model.value.clone());
if let Some(candidate) = &pending.candidate
&& !model.values.iter().any(|v| v.value == candidate.value)
{
model.values.push(candidate.clone());
}
model.current = Some(choice.value.clone());
task.config.retain(|o| !config::is_per_model_option(o));
task.config.extend(pending.options.iter().cloned().map(|mut option| {
if let Some(choice) = pending.choices.iter().find(|choice| choice.id == option.id) {
option.current = Some(choice.value.clone());
}
option
}));
}
task
}
}
struct DiscoveringModel<'a> {
state: &'a Mutex<TaskState>,
generation: u64,
}
impl Drop for DiscoveringModel<'_> {
fn drop(&mut self) {
let mut s = self.state.lock();
if s.discovering_model == Some(self.generation) {
s.discovering_model = None;
}
}
}
/// A running agent and its session.
#[derive(Clone)]
struct Live {
@@ -839,7 +796,6 @@ impl AgentManager {
entries: Vec::new(),
wanted: Vec::new(),
pending_model: None,
pending_switch: None,
before: BTreeMap::new(),
saved: None,
touched: Some(BTreeSet::new()),
@@ -956,7 +912,6 @@ impl AgentManager {
entries: Vec::new(),
wanted: req.config,
pending_model: None,
pending_switch: None,
before,
saved,
touched: (req.isolation == Isolation::Local).then(BTreeSet::new),
@@ -994,9 +949,6 @@ impl AgentManager {
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
if s.discovering_model.is_some() {
return Err(IdeError::unavailable("Model settings are still loading"));
}
if s.busy {
let item = AgentQueued { id: uuid::Uuid::new_v4().simple().to_string(), prompt };
if now {
@@ -1116,24 +1068,6 @@ impl AgentManager {
let task = self.task(id)?;
let (target, change) = {
let mut s = task.state.lock();
let busy = s.busy;
let archived = s.task.status == AgentStatus::Archived;
if let Some(pending) = &mut s.pending_model
&& let Some(target) = pending.options.iter().find(|o| o.id == option)
{
if archived || busy {
return Err(IdeError::invalid("The pending model settings cannot be changed now"));
}
if !target.values.iter().any(|v| v.value == value) {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
}
pending.choices.retain(|c| c.id != option);
pending.choices.push(AgentConfigChoice { id: option.to_owned(), value });
drop(s);
task.persist();
task.emit_task();
return Ok(());
}
let target = s
.task
.config
@@ -1141,9 +1075,6 @@ impl AgentManager {
.find(|o| o.id == option)
.ok_or_else(|| IdeError::not_found("no such setting"))?
.clone();
if s.pending_model.is_some() && config::is_per_model_option(&target) {
return Err(IdeError::invalid("This setting is not available on the selected model"));
}
if !target.values.iter().any(|v| v.value == value) {
if target.category.as_deref() != Some("model") {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
@@ -1152,12 +1083,8 @@ impl AgentManager {
} else {
let switching_model = target.category.as_deref() == Some("model");
if switching_model {
if s.pending_model.is_some() && s.busy {
return Err(IdeError::invalid("The pending model settings cannot be changed now"));
}
s.model_choice += 1;
s.pending_model = None;
s.discovering_model = None;
}
let previous_levels = (switching_model && target.current.as_deref() != Some(value.as_str()))
.then(|| s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>());
@@ -1189,19 +1116,33 @@ impl AgentManager {
&& (previous.as_deref() != Some(value.as_str()) || !model_options)
{
let provider = task.state.lock().task.provider.clone();
let levels = self.shared.paths.catalogs.load_levels(&self.shared, &provider, &value).await;
let mut levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
let mut error = None;
if levels.is_none()
&& let Some(spec) = self.shared.spec(&provider)
{
let (catalog, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, Some(&value));
error = catalog.error;
if let Some(mut ready) = flight {
while !*ready.borrow_and_update() {
if ready.changed().await.is_err() {
break;
}
}
}
levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
}
// Another selection may have superseded this discovery while it was waiting.
if task.state.lock().model_choice != model_choice {
return Ok(());
}
let levels = match levels {
Ok(levels) => levels,
Err(error) => {
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
task.persist();
task.emit_task();
return Err(IdeError::unavailable(error));
}
let Some(levels) = levels else {
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
task.persist();
task.emit_task();
return Err(IdeError::unavailable(
error.unwrap_or_else(|| "The agent did not report settings for the selected model".into()),
));
};
let mut s = task.state.lock();
if s.model_choice != model_choice {
@@ -1324,7 +1265,6 @@ impl AgentManager {
entries,
wanted: s.wanted.clone(),
pending_model: None,
pending_switch: None,
before: (*s.before).clone(),
saved: s.saved.clone(),
touched: s.touched.as_deref().cloned(),
@@ -1370,8 +1310,6 @@ impl AgentManager {
};
s.session_id = None;
s.pending_model = None;
s.model_choice += 1;
s.discovering_model = None;
s.conversation = Conversation::default();
// The fresh session reports its own usage; nothing carries over.
s.task.usage = None;
@@ -1970,24 +1908,6 @@ impl Task {
let mut task = file.task;
config::add_client_options(&task.provider, &mut task.config);
let conversation = Conversation::restore(file.entries, file.subagents);
let mut wanted = file.wanted;
let pending_model = file.pending_switch.or_else(|| {
let id = file.pending_model?;
let index = wanted.iter().position(|choice| choice.id == id)?;
let model = wanted.remove(index);
if let Some(value) = task.model.clone() {
wanted.push(AgentConfigChoice { id, value });
}
let catalog = shared.paths.catalogs.cached(&shared, &task.provider);
let candidate = catalog
.config
.iter()
.find(|o| o.category.as_deref() == Some("model"))
.and_then(|o| o.values.iter().find(|v| v.value == model.value))
.cloned();
let options = catalog.thought_levels.get(&model.value).cloned().unwrap_or_default();
Some(PendingModel { model, candidate, options, choices: Vec::new() })
});
Arc::new(Self {
id: task.id.clone(),
shared,
@@ -1995,10 +1915,9 @@ impl Task {
task,
session_id: file.session_id,
conversation,
wanted,
pending_model,
wanted: file.wanted,
pending_model: file.pending_model,
model_choice: 0,
discovering_model: None,
before: Arc::new(file.before),
saved: file.saved,
touched: file.touched.map(Arc::new),
@@ -2192,8 +2111,7 @@ impl Task {
session_id: s.session_id.clone(),
entries: s.conversation.main.entries.clone(),
wanted: s.wanted.clone(),
pending_model: None,
pending_switch: s.pending_model.clone(),
pending_model: s.pending_model.clone(),
before: (*s.before).clone(),
saved: s.saved.clone(),
touched: s.touched.as_deref().cloned(),
@@ -2346,18 +2264,13 @@ impl Task {
let candidate = self.shared.paths.catalogs.fresh_model(&self.shared, &spec, &value).ok_or_else(|| {
IdeError::invalid(format!("{} has no value {value} in the current model catalog", target.name))
})?;
let selection = {
let model_choice = {
let mut s = self.state.lock();
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
s.model_choice += 1;
s.discovering_model = Some(s.model_choice);
DiscoveringModel { state: &self.state, generation: s.model_choice }
s.model_choice
};
let model_choice = selection.generation;
// A prompt starting during the switch must not grab the peer we're about to recycle.
let connecting = self.connecting.lock().await;
let _connecting = self.connecting.lock().await;
{
let s = self.state.lock();
if s.model_choice != model_choice {
@@ -2380,16 +2293,16 @@ impl Task {
Ok(None)
};
let refused = match result {
Ok(Some(reply)) => {
let (config, model) = {
let mut s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
let accepted = {
let mut s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
let pending = match result {
Ok(Some(reply)) => {
if let Some(options) = reply.get("configOptions") {
config::merge_update(&mut s.task.config, options);
} else if s.task.model.as_deref() != Some(value.as_str()) {
@@ -2408,66 +2321,36 @@ impl Task {
model.current = Some(value.clone());
s.task.model = Some(value.clone());
sync_usage_context_size(&mut s.task);
s.pending_model = None;
s.wanted.retain(|c| c.id != target.id);
s.wanted.push(AgentConfigChoice { id: target.id, value });
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
(s.task.config.clone(), model)
};
self.shared.remember(&provider, Some(&config), None, model.as_deref());
self.persist();
self.emit_task();
return Ok(());
}
refused => refused,
false
}
refused => {
if s.session_id.is_none()
|| live.as_ref().is_some_and(|l| !l.resumable)
|| self.start_fresh.load(Ordering::Acquire)
{
return Err(IdeError::unavailable(
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
));
}
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
return Err(IdeError::invalid("wait until the agent is done"));
}
true
}
};
s.wanted.retain(|c| c.id != target.id);
s.pending_model = pending.then(|| target.id.clone());
s.wanted.push(AgentConfigChoice { id: target.id, value });
(!pending).then(|| {
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
(s.task.config.clone(), model)
})
};
{
let s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.session_id.is_none()
|| live.as_ref().is_some_and(|l| !l.resumable)
|| self.start_fresh.load(Ordering::Acquire)
{
return Err(IdeError::unavailable(
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
));
}
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
return Err(IdeError::invalid("wait until the agent is done"));
}
if let Some((config, model)) = accepted {
self.shared.remember(&provider, Some(&config), None, model.as_deref());
} else {
self.recycle_resumable_session();
}
// Catalog discovery never owns the chat session. Let a newer model choice supersede it.
drop(connecting);
let options = self.shared.paths.catalogs.load_levels(&self.shared, &provider, &value).await;
let _connecting = self.connecting.lock().await;
{
let mut s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
return Err(IdeError::invalid("wait until the agent is done"));
}
let options = options.map_err(IdeError::unavailable)?;
let choices = s
.pending_model
.take()
.filter(|pending| pending.model.value == value)
.map(|pending| pending.choices)
.unwrap_or_default();
s.pending_model = Some(PendingModel {
model: AgentConfigChoice { id: target.id, value },
candidate: Some(candidate),
options,
choices,
});
}
self.recycle_resumable_session();
self.persist();
self.emit_task();
Ok(())
@@ -2729,9 +2612,10 @@ impl Task {
}
let (provider_id, cwd, saved, pending) = {
let s = self.state.lock();
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), s.pending_model.clone())
let pending = s.pending_model().map(|choice| (choice.clone(), s.task.model.clone()));
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), pending)
};
let pending_model = pending.as_ref();
let pending_model = pending.as_ref().map(|(choice, _)| choice);
let raw_spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
let can_fallback =
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
@@ -2757,12 +2641,22 @@ impl Task {
let live = match opened {
Ok(live) => live,
Err(err) => {
let mut s = self.state.lock();
if pending.is_some() && s.pending_model == pending {
s.pending_model = None;
drop(s);
self.persist();
self.emit_task();
if let Some((choice, previous)) = pending {
let mut s = self.state.lock();
if s.pending_model() == Some(&choice) {
s.pending_model = None;
s.wanted.retain(|c| c.id != choice.id);
if let Some(model) = s.task.config.iter_mut().find(|o| o.id == choice.id) {
model.current.clone_from(&previous);
}
s.task.model.clone_from(&previous);
if let Some(value) = previous {
s.wanted.push(AgentConfigChoice { id: choice.id, value });
}
drop(s);
self.persist();
self.emit_task();
}
}
return Err(err.message);
}
@@ -2777,7 +2671,7 @@ impl Task {
spec: provider::ProviderSpec,
cwd: &Path,
saved: Option<String>,
pending_model: Option<&PendingModel>,
pending_model: Option<&AgentConfigChoice>,
) -> Result<Live, SessionOpenError> {
let launch_cwd = cwd.to_path_buf();
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
@@ -2803,15 +2697,14 @@ impl Task {
}
});
// Speaks ACP v1 or v2, whichever the agent chooses; the task sees v1 either way.
let client = Client::new(self, saved.as_deref().filter(|_| pending_model.is_some()));
let handler = acp::Dialect::wrap(client.clone());
let client = acp::Dialect::wrap(Arc::new(Client { task: Arc::downgrade(self) }));
let raw_peer =
(self.shared.connector)(&spec, cwd, handler.clone(), on_stderr).map_err(|e| SessionOpenError {
(self.shared.connector)(&spec, cwd, client.clone(), on_stderr).map_err(|e| SessionOpenError {
message: format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command),
allow_acp_fallback: !native::copilot::is_missing_binary_error(&e),
})?;
let mut stop_on_err = KillOnDrop(Some(raw_peer.clone()));
let peer = acp::Conn::new(raw_peer, handler);
let peer = acp::Conn::new(raw_peer, client);
let init = peer.initialize(&client_info()).await.map_err(|e| {
let is_auth = matches!(&e, RpcError::Server { code, message, .. } if acp::auth_required(*code, message));
@@ -2910,13 +2803,7 @@ impl Task {
// The session's settings, then the user's choices on top.
// A session that reports none keeps the last known ones, but what is set is unknown.
let mut reported = config::options_of(&result);
if let Some(update) = client.take_opening_config()
&& let Some(config) = update.get("configOptions")
&& reported.iter().all(|o| o.category.as_deref() != Some("model"))
{
config::merge_update(&mut reported, config);
}
let reported = config::options_of(&result);
let known = !reported.is_empty();
if known {
self.shared.remember(provider_id, Some(&reported), None, model_of(&reported).as_deref());
@@ -2924,33 +2811,19 @@ impl Task {
let (mut options, mut wanted) = {
let s = self.state.lock();
let options = if known { reported } else { s.task.config.clone() };
let mut wanted = s.wanted.clone();
if let Some(pending) = pending_model {
pending.apply(&mut wanted, &s.task.config);
}
let wanted = s.wanted.clone();
(options, wanted)
};
config::add_client_options(provider_id, &mut options);
// Changing model can replace the effort / context-tier choices; validate those only afterwards.
wanted.sort_by_key(|c| {
if let Some(pending) = pending_model {
if c == &pending.model {
return 0;
}
if pending.choices.contains(c) {
return 2;
}
}
match options.iter().find(|o| o.id == c.id) {
Some(o) if o.category.as_deref() == Some("model") => 0,
Some(o) if config::is_per_model_option(o) => 2,
_ => 1,
}
wanted.sort_by_key(|c| match options.iter().find(|o| o.id == c.id) {
Some(o) if o.category.as_deref() == Some("model") => 0,
Some(o) if config::is_per_model_option(o) => 2,
_ => 1,
});
let mut model_options = known;
for choice in &wanted {
let pending = pending_model.is_some_and(|p| &p.model == choice);
let explicit = pending_model.is_some_and(|p| p.choices.contains(choice));
let pending = pending_model == Some(choice);
if pending
&& !options.iter().any(|o| {
o.id == choice.id
@@ -2963,19 +2836,6 @@ impl Task {
allow_acp_fallback: false,
});
}
if explicit
&& (!model_options
|| !options.iter().any(|o| {
o.id == choice.id
&& config::is_per_model_option(o)
&& o.values.iter().any(|v| v.value == choice.value)
}))
{
return Err(SessionOpenError {
message: format!("The selected model no longer offers {} value {}.", choice.id, choice.value),
allow_acp_fallback: false,
});
}
// An option the session doesn't offer yet is set once it does (`apply_late_choices`).
let Some(o) = options.iter().find(|o| o.id == choice.id).cloned() else { continue };
if o.id == config::CURSOR_APPROVAL {
@@ -2987,7 +2847,7 @@ impl Task {
if config::is_per_model_option(&o) && !model_options {
continue;
}
let already = (known || explicit) && o.current.as_deref() == Some(choice.value.as_str());
let already = known && o.current.as_deref() == Some(choice.value.as_str());
if already || !o.values.iter().any(|v| v.value == choice.value) {
continue;
}
@@ -2996,30 +2856,14 @@ impl Task {
params["sessionId"] = json!(session_id);
match peer.request::<_, Value>(method, params, None).await {
Ok(reply) => {
let observed = client.take_opening_config();
let report =
if reply.get("configOptions").is_some() { &reply } else { observed.as_ref().unwrap_or(&reply) };
if pending && !config::accepts_model(report, &o.id, &choice.value) {
if pending && !config::accepts_model(&reply, &o.id, &choice.value) {
return Err(SessionOpenError {
message: format!("The reloaded session did not switch to model {}.", choice.value),
allow_acp_fallback: false,
});
}
if let Some(fresh) = report.get("configOptions") {
if let Some(fresh) = reply.get("configOptions") {
config::merge_update(&mut options, fresh);
if explicit
&& !options.iter().any(|option| {
option.id == choice.id && option.current.as_deref() == Some(choice.value.as_str())
})
{
return Err(SessionOpenError {
message: format!(
"The selected model did not accept {} value {}.",
choice.id, choice.value
),
allow_acp_fallback: false,
});
}
model_options = true;
} else if o.category.as_deref() == Some("model") {
if o.current.as_deref() != Some(choice.value.as_str()) {
@@ -3031,7 +2875,7 @@ impl Task {
o.current = Some(choice.value.clone());
}
}
Err(e) if pending || explicit => {
Err(e) if pending => {
return Err(SessionOpenError { message: self.describe(e), allow_acp_fallback: false });
}
Err(e) => tracing::warn!("agent task {}: setting {} to {} failed: {e}", self.id, o.id, choice.value),
@@ -3041,16 +2885,6 @@ impl Task {
self.shared.remember(provider_id, Some(&options), None, model.as_deref());
{
let mut s = self.state.lock();
if let Some(pending) = pending_model {
if s.pending_model.as_ref() != Some(pending) {
return Err(SessionOpenError {
message: "The pending model settings changed while reopening the session.".into(),
allow_acp_fallback: false,
});
}
let TaskState { task, wanted, .. } = &mut *s;
pending.apply(wanted, &task.config);
}
s.task.model = model_of(&options).or(s.task.model.take());
s.task.config = options;
s.pending_model = None;
@@ -3060,7 +2894,6 @@ impl Task {
// The (re)started process runs nothing yet: whatever it reports next is all of it.
s.background_tasks = Vec::new();
s.task.background.clear();
*client.opening_config.lock() = None;
}
self.persist();
self.emit_task();
@@ -3528,28 +3361,6 @@ impl Task {
/// Answers the agent's requests on behalf of one task.
struct Client {
task: Weak<Task>,
opening_config: Mutex<Option<OpeningConfig>>,
}
/// Config replays belong to the candidate connection until its model and settings are confirmed.
struct OpeningConfig {
session: String,
options: Option<Value>,
}
impl Client {
fn new(task: &Arc<Task>, opening_session: Option<&str>) -> Arc<Self> {
Arc::new(Self {
task: Arc::downgrade(task),
opening_config: Mutex::new(
opening_session.map(|id| OpeningConfig { session: id.to_owned(), options: None }),
),
})
}
fn take_opening_config(&self) -> Option<Value> {
self.opening_config.lock().as_mut()?.options.take()
}
}
impl Handler for Client {
@@ -3566,14 +3377,6 @@ impl Handler for Client {
if method == "session/update"
&& let (Some(task), Some(update)) = (self.task.upgrade(), params.get("update"))
{
if update.get("sessionUpdate").and_then(Value::as_str) == Some("config_option_update")
&& let Some(opening) = self.opening_config.lock().as_mut()
{
if params.get("sessionId").and_then(Value::as_str) == Some(opening.session.as_str()) {
opening.options = Some(update.clone());
}
return;
}
task.on_update(params.get("sessionId").and_then(Value::as_str), update);
}
}
+1 -1
Переглянути файл
@@ -1935,7 +1935,7 @@ async fn startup_warnings_survive_replay_and_restart_without_failing_the_task()
let handle = mgr.task(&task.id).unwrap();
handle.replaying.store(true, Ordering::Release);
handle.turn_started.store(false, Ordering::Release);
let client = Client::new(&handle, None);
let client = Client { task: Arc::downgrade(&handle) };
client.on_notification(WARNING_NOTIFICATION, json!({"message": "Project MCP config is disabled until trusted."}));
client.on_notification(WARNING_NOTIFICATION, json!({"message": " "}));
client.on_notification(WARNING_NOTIFICATION, json!({}));
-9
Переглянути файл
@@ -170,12 +170,6 @@ pub struct CommitSettings {
pub double_click_opens_diff: Option<bool>,
/// Team conventions for Generate Commit Message with Agent, added to its prompt.
pub agent_instructions: String,
/// The coding agent Generate Commit Message with Agent uses; empty follows the latest task's agent.
pub agent: String,
/// That agent's model for commit messages; empty keeps the model the agent would use.
pub agent_model: String,
/// That model's thinking level for commit messages; empty keeps the agent's.
pub agent_effort: String,
}
impl Default for CommitSettings {
@@ -198,9 +192,6 @@ impl Default for CommitSettings {
disabled_plugin_checks: Vec::new(),
double_click_opens_diff: None,
agent_instructions: String::new(),
agent: String::new(),
agent_model: String::new(),
agent_effort: String::new(),
}
}
}
+1 -47
Переглянути файл
@@ -119,29 +119,6 @@ fn php_cs_fixer_edits(
.collect())
}
/// Some language servers (Vue's, for one) answer Reformat Code with one edit replacing the
/// whole file; applied as is, it moves the caret and the view to the top of the file. The same
/// result as one edit per changed region keeps them where they were.
fn minimal_edits(text: &str, edits: Vec<TextEdit>) -> Vec<TextEdit> {
if !edits.iter().any(|e| e.range.end.line > e.range.start.line) {
return edits;
}
let original = ide_text::Document::new(text);
let mut formatted = original.clone();
if formatted.apply_edits(&edits).is_err() {
return edits;
}
original
.diff(&formatted.text())
.changes
.into_iter()
.map(|c| TextEdit {
range: Range::new(original.offset_to_pos(c.from), original.offset_to_pos(c.to)),
new_text: c.insert,
})
.collect()
}
pub async fn format(
host: &Host,
window: &str,
@@ -315,11 +292,7 @@ async fn provider_edits(
if options.on_save && !settings.editor.format_on_save {
return Ok(None);
}
let edits = project.lsp.format(doc, range, options).await?;
let text = snap.text;
return tokio::task::spawn_blocking(move || Some(minimal_edits(&text, edits)))
.await
.map_err(|e| IdeError::internal(e.to_string()));
return project.lsp.format(doc, range, options).await.map(Some);
};
let tool_settings = settings.languages.formatter(selected);
if options.on_save && !tool_settings.run_on_save {
@@ -550,25 +523,6 @@ mod tests {
const ALIGN: PhpAlignment = PhpAlignment { key_value_pairs: true, assignments: true };
#[test]
fn a_whole_file_edit_becomes_one_edit_per_changed_region() {
let text = "a\n b\nc\nd\n e\n";
let formatted = "a\nb\nc\nd\ne\n";
let whole = vec![TextEdit { range: Range::new(Pos::new(0, 0), Pos::new(5, 0)), new_text: formatted.into() }];
let edits = minimal_edits(text, whole);
assert_eq!(
edits,
[
TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 2)), new_text: String::new() },
TextEdit { range: Range::new(Pos::new(4, 0), Pos::new(4, 2)), new_text: String::new() },
]
);
assert_eq!(after(text, &edits), formatted);
// Single-line edits are already minimal and pass through.
let small = vec![TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 2)), new_text: String::new() }];
assert_eq!(minimal_edits(text, small.clone()), small);
}
#[test]
fn php_alignment_is_off_unless_the_php_code_style_turns_it_on() {
let php = LanguageId::new("php");
+2 -4
Переглянути файл
@@ -902,11 +902,9 @@ fn always_update_snapshots_adds_dash_u_once() {
apply_to_run_configs(&mut own, tmp.path(), &s);
assert_eq!(own[0].args, ["--update-snapshots", "package"]);
// Settings apply to the stored configuration at each launch, so turning it off drops -U.
s.languages.java.maven.update_snapshots = false;
let mut stored = vec![run("maven", "./mvnw", &["package"])];
apply_to_run_configs(&mut stored, tmp.path(), &s);
assert_eq!(stored[0].args, ["package"]);
apply_to_run_configs(&mut configs, tmp.path(), &s);
assert_eq!(configs[0].args, ["package"]);
}
#[test]
-3
Переглянути файл
@@ -847,9 +847,6 @@ mod tests {
"disabledPluginChecks": [],
"doubleClickOpensDiff": null,
"agentInstructions": "",
"agent": "",
"agentModel": "",
"agentEffort": "",
})
);
}
+2 -34
Переглянути файл
@@ -29,13 +29,7 @@ pnpm perf -- --only typing --profile --unminified # CPU profile and top functi
Other options: `--warmup <n>` (default 1), `--headed`, `--no-build` (reuse the last build), `--channel <browser>` (default `chromium`, or `OPENIDEA_PERF_CHANNEL`), `--fail-on-regression`.
`--runs` must be a positive integer, `--warmup` a nonnegative integer, and `--cpu` a finite number of at least 1. Empty or unknown `--only` entries fail before building or launching a browser. Every declared selected scenario must return exactly one result; missing budgeted metrics and nonfinite metrics fail even when CPU throttling disables timing-budget enforcement. Unminified profiling builds intentionally omit bundle-size checks.
Every attempted repetition, including warmups, is retained in `target/perf/report.json` with status, metrics and failure reason. Markdown shows valid/planned and attempted counts. Missing or nonfinite repetitions are not filtered out of medians; invalid warmups also fail the scenario. Build, browser and cleanup failures replace the previous report with a fresh failure.
UI builds and individual trials have five-minute wall-clock deadlines independent of renderer animation frames. Browser startup is bounded to 30 seconds; context/HTTP cleanup to five seconds, with bounded forced browser termination. The owned Playwright browser server adds a local WebSocket command hop; in-page timing clocks are unchanged.
Scenarios (`perf/scenarios.ts`): `typing`, `typingLarge`, `typingAngular`, `completion`, `consoleOutput`, `terminalTui`, `keyRepeat`, `scroll`, `gitLog`, `gitLogScrollbar`, `resizePanels`, `startup`, `tabs`, `agentTabs`, `popups`, `toolWindows`, `projectTree`, `leaks`. Bundle size (`bundle.initialJsKb`, `bundle.initialCssKb`) is checked except with `--unminified`.
Scenarios (`perf/scenarios.ts`): `typing`, `typingLarge`, `typingAngular`, `completion`, `consoleOutput`, `terminalTui`, `keyRepeat`, `scroll`, `gitLog`, `gitLogScrollbar`, `resizePanels`, `startup`, `tabs`, `agentTabs`, `popups`, `toolWindows`, `projectTree`, `leaks`. Bundle size (`bundle.initialJsKb`, `bundle.initialCssKb`) is checked on every run.
Latencies are measured from input to the start of the first frame that shows the result, so about 16.7 ms means "next frame".
@@ -48,17 +42,9 @@ Latencies are measured from input to the start of the first frame that shows the
A scenario in `perf/scenarios.ts` has an `id`, a `title` and a `run(h)` that drives the page through the harness (`perf/lib/harness.ts`: open files, set the cursor, type and measure, read editor state) and returns metrics. Add a budget for each metric you want enforced as `"<scenario>.<metric>"` in `budgets.json`.
### Current-operation checks
An already-visible result is not evidence that the measured action worked. Interaction waits require a current input and the requested state transition; file opening checks the active full path, typing checks the resulting text/caret and key-sample count, and scroll/completion navigation checks its destination.
Code-intelligence evals also wait for successful action completion. Rename correctness uses the current matching request only: multi-file previews validate proposed edits, while applied local renames validate the edited document. Incomplete answers are degraded results. Clean-file diagnostics require a fresh backend publication for that document, including an explicitly empty publication; a quiet empty UI alone cannot pass.
Diagnostics acknowledgements match the path, backend source and local opening token. Backend publications carry no document version, so a delayed same-path publication after reopening cannot be distinguished from a newly computed one.
## Backend: `pnpm perf:rust`
`perf/rust.ts` runs `cargo bench` for `ide-text`, `ide-language`, `ide-index`, `ide-search`, `ide-host` and `ide-heap`, reads the Criterion results, and checks each bench's mean (in µs).
`perf/rust.ts` runs `cargo bench` for `ide-text`, `ide-language`, `ide-index`, `ide-search` and `ide-host`, reads the Criterion results from `target/criterion`, and checks each bench's mean (in µs).
```sh
pnpm perf:rust # run the benches, then check
@@ -76,22 +62,6 @@ The benches live in `crates/<crate>/benches/`:
| `search_5k/…` | `ide-search` | literal, regex and dense-match search over 5k files |
| `plugins/…` | `ide-host` | loading 50 plugins, cold activation, syntax highlights of a 2k-line file |
Expected IDs and package ownership are declared independently of collected artifacts in `perf/lib/rust.ts`. A selected package must produce every expected ID, including observe-only measurements. `--package` scopes both collection and required budgets, also with `--no-run`; unknown packages fail before Cargo starts.
Six IDs are observe-only (required finite measurements, without an absolute budget): `syntax_2mb/outline_uncached`, `syntax_2mb/folding_uncached`, `index_100k/find_files/zzzz`, `index_100k/find_symbols/renderView`, `startup_20k/reopen_wait_idle`, and `search_excluded_subtrees/5k_dependencies`. New IDs need an explicit budget or observe-only classification.
Normal runs write isolated `<Criterion root>/runs/run-*/criterion` artifacts, a `run.json` manifest and Cargo logs. `CRITERION_HOME` and `CARGO_TARGET_DIR` are passed consistently to Cargo. Both artifact files must fall within the recorded run window; future timestamps fail. `--no-run` inspects the newest recorded run covering the selected packages, retaining original artifact dates and any recorded failure; pre-manifest output is explicitly labelled legacy inspection, not current execution.
Cargo has a 60-minute deadline including cold compilation (`PERF_RUST_TIMEOUT_MS` overrides milliseconds), followed by bounded process-tree termination. Cargo, artifact and manifest failures write fresh `report-rust.json` and Markdown with partial evidence.
## Code intelligence: `pnpm eval`
Use `pnpm eval --list` for scenario IDs and supported conditions. `--only` accepts comma-separated IDs or dot-prefix groups; every entry must match executable work. `--condition` accepts only `warm` or `cold`, and a selection incompatible with that condition is rejected before building or launching. Repetition counts follow the UI runner's integer requirements.
The selected scenario/condition plan defines the required outcomes independently of collected results. Missing, duplicate or unexpected outcomes fail; an empty workload cannot pass. Required timing and correctness metrics must be present and finite, rather than silently skipped by the judge.
Raw attempts, warmups, results and partial timeout timings remain in `target/eval/report.json`; invalid trials cannot disappear into an otherwise valid median. Startup/build failures also produce a fresh failing report. Session startup, fixture setup and each trial have five-minute wall-clock bounds; renderer measurements additionally have a Node deadline one second beyond their configured timeout. Server initialization is limited to 30 seconds, individual stdio requests to five minutes, release compilation to 60 minutes. Cleanup errors fail the run.
## Budgets and baselines
[`perf/budgets.json`](https://github.com/l0ng-ai/openidea/blob/main/perf/budgets.json) holds upper bounds (lower is better):
@@ -122,6 +92,4 @@ python perf/compare/bench.py ~/src/some-project --runs 5 --wipe-caches # cold
Each run launches the app on the project, waits until it is ready (the process tree's CPU stays low after the window and the log markers appear), idles, closes it, and records time to window and to ready, peak and idle memory summed over every process the app started (webview, language servers, JVMs), CPU time, exit time and cache size. Apps run interleaved after warmup runs; output goes to `results/<time>-<project>/` (`report.md`, `results.json`).
Reports retain failed trials and warmups, display per-cell valid/attempted counts, and distinguish unsupported metrics from missing required values. Startup timeouts, crashes, forced shutdowns and interruptions fail the command. Quit/cache commands have explicit deadlines; cleanup runs even after observation failures. See the comparison README for the unchanged CPU-settled readiness proxy and daemon exclusions.
Use release builds only; the script refuses to run while another instance of the same executable is running. See [`perf/compare/README.md`](https://github.com/l0ng-ai/openidea/blob/main/perf/compare/README.md) for fair-run rules and platform notes.
+1 -1
Переглянути файл
@@ -78,7 +78,7 @@ The task tab shows the conversation: your messages, the agent's replies, its rea
On your own messages you can **Edit** (the messages after it are replaced; files already changed stay as they are) or **Retract Message**. On replies you can **Copy Markdown**, **Quote Reply**, **Regenerate Response** and **Branch Conversation from Here**, which starts a new task from that point.
In an existing chat, open **Model › Refresh models** to discover newly available models without sending a message or changing the selection. If the agent can't switch in place, the choice stays pending. You can choose an effort level as soon as the provider reports the new model's options. On your next message, OpenIDEA reopens the same session and applies the model and any effort you selected before sending. If the session can't be reopened or rejects either choice, OpenIDEA restores the previous selection and reports the error without sending the message.
In an existing chat, open **Model › Refresh models** to discover newly available models without sending a message or changing the selection. If the agent can't switch in place, the choice stays pending until your next message reopens the same session. If the session can't be reopened or doesn't accept the model, OpenIDEA restores the previous selection and reports the error without sending the message.
**Focus Agent Input** defaults to `⌘L` on macOS and `Ctrl+L` on Windows / Linux in every built-in keymap. When focus is inside your writable task conversation, in either an editor tab or the tool window, it returns focus to the message input without changing your draft, caret position or selection—even when pressed repeatedly. It does not send a message or jump through message history.
+2 -34
Переглянути файл
@@ -29,13 +29,7 @@ pnpm perf -- --only typing --profile --unminified # CPU profile 和耗时最
其他选项:`--warmup <n>`(默认 1)、`--headed`、`--no-build`(复用上次构建)、`--channel <browser>`(默认 `chromium`,或 `OPENIDEA_PERF_CHANNEL`)、`--fail-on-regression`。
`--runs` 必须为正整数,`--warmup` 为非负整数,`--cpu` 为不小于 1 的有限数值。`--only` 中的空项或未知场景会在构建或启动浏览器前报错。每个选中场景必须恰好返回一份结果;预算指标缺失或指标非有限值都会失败,即使 CPU 降速关闭了耗时预算检查。未压缩的性能分析构建不检查包体积。
`target/perf/report.json` 保留每次尝试(包括预热)的状态、指标和失败原因,Markdown 显示有效/计划次数及实际尝试次数。缺失或非有限值不会从中位数中被过滤,预热无效也会导致场景失败。构建、浏览器和清理失败都会用新的失败报告替换旧报告。
UI 构建和每次尝试都有独立于渲染器动画帧的五分钟墙钟期限。浏览器启动限时 30 秒,上下文及 HTTP 清理限时五秒,必要时有界强制终止浏览器。独立管理的 Playwright 浏览器服务增加一次本地 WebSocket 命令跳转,页面内计时基准不变。
场景(`perf/scenarios.ts`):`typing`、`typingLarge`、`typingAngular`、`completion`、`consoleOutput`、`terminalTui`、`keyRepeat`、`scroll`、`gitLog`、`gitLogScrollbar`、`resizePanels`、`startup`、`tabs`、`agentTabs`、`popups`、`toolWindows`、`projectTree`、`leaks`。除 `--unminified` 外,每次运行都会检查包体积(`bundle.initialJsKb`、`bundle.initialCssKb`)。
场景(`perf/scenarios.ts`):`typing`、`typingLarge`、`typingAngular`、`completion`、`consoleOutput`、`terminalTui`、`keyRepeat`、`scroll`、`gitLog`、`gitLogScrollbar`、`resizePanels`、`startup`、`tabs`、`agentTabs`、`popups`、`toolWindows`、`projectTree`、`leaks`。每次运行都会检查包体积(`bundle.initialJsKb`、`bundle.initialCssKb`)。
延迟是从输入到显示结果的第一帧开始的时间,因此约 16.7 ms 就表示“下一帧”。
@@ -48,17 +42,9 @@ UI 构建和每次尝试都有独立于渲染器动画帧的五分钟墙钟期
`perf/scenarios.ts` 中的场景包含 `id`、`title` 和 `run(h)`:通过 harness(`perf/lib/harness.ts`:打开文件、设置光标、输入并测量、读取编辑器状态)驱动页面并返回指标。需要强制检查的指标,在 `budgets.json` 中以 `"<scenario>.<metric>"` 加上预算。
### 当前操作的正确性检查
已显示的结果不能证明被测操作成功。交互等待必须观察到当前输入及目标状态变化;打开文件会核对活动编辑器的完整路径,输入会核对最终文本、光标和按键样本数,滚动及补全导航会核对目标位置。
代码智能 eval 也会等待动作成功结束。重命名只使用当前匹配请求的结果:跨文件预览验证拟议的修改,已应用的局部重命名验证实际文档。不完整的答复按降级结果处理。干净文件的诊断必须收到针对该文档的新后端发布,包括明确的空发布;仅有安静且为空的 UI 不能通过。
诊断确认匹配路径、后端来源和本地打开令牌。后端发布不携带文档版本,因此重新打开后延迟到达的同路径发布,无法与新计算的发布区分。
## 后端:`pnpm perf:rust`
`perf/rust.ts` 对 `ide-text`、`ide-language`、`ide-index`、`ide-search`、`ide-host` 和 `ide-heap` 运行 `cargo bench`,读取 Criterion 结果,检查每个基准的平均值(µs)。
`perf/rust.ts` 对 `ide-text`、`ide-language`、`ide-index`、`ide-search` 和 `ide-host` 运行 `cargo bench`,从 `target/criterion` 读取 Criterion 结果,检查每个基准的平均值(µs)。
```sh
pnpm perf:rust # 跑基准并检查
@@ -76,22 +62,6 @@ pnpm perf:rust -- --package ide-text --save-baseline
| `search_5k/…` | `ide-search` | 在 5 千个文件中做字面量、正则和密集匹配搜索 |
| `plugins/…` | `ide-host` | 加载 50 个插件、冷激活、2 千行文件的语法高亮 |
预期 ID 及其所属包在 `perf/lib/rust.ts` 中独立于收集到的产物声明。选中的包必须提供全部预期 ID,包括仅观察的指标。`--package` 同时限定收集范围和必需预算,使用 `--no-run` 时也如此;未知包会在启动 Cargo 前报错。
六个 ID 仅观察(必须提供有限测量值,但没有绝对预算):`syntax_2mb/outline_uncached`、`syntax_2mb/folding_uncached`、`index_100k/find_files/zzzz`、`index_100k/find_symbols/renderView`、`startup_20k/reopen_wait_idle`、`search_excluded_subtrees/5k_dependencies`。新增 ID 必须明确设置预算或归类为仅观察。
正常执行将产物隔离到 `<Criterion 根目录>/runs/run-*/criterion`,并保留 `run.json` 清单和 Cargo 日志。`CRITERION_HOME`、`CARGO_TARGET_DIR` 与 Cargo 保持一致。两个产物文件都必须处于记录的运行时间窗口内,未来时间戳会失败。`--no-run` 检查覆盖所选包的最新记录,保留原始产物时间及已有失败;清单引入前的产物明确标为旧产物检查,而非本次执行。
Cargo 包括冷编译在内默认限时 60 分钟(`PERF_RUST_TIMEOUT_MS` 可按毫秒覆盖),随后有界终止所属进程树。Cargo、产物和清单失败都会输出新的 `report-rust.json` 和 Markdown,并保留部分证据。
## 代码智能:`pnpm eval`
用 `pnpm eval --list` 查看场景 ID 及支持的条件。`--only` 接受逗号分隔的 ID 或点号前缀分组;每项都必须匹配可执行的工作。`--condition` 只接受 `warm` 或 `cold`,与该条件不兼容的选择会在构建或启动前被拒绝。重复次数遵循 UI 运行器的整数要求。
选中的场景/条件计划独立于收集结果定义必需的输出。缺失、重复或非预期输出都会失败,空工作集不能通过。必需的耗时和正确性指标必须存在且为有限数值,判定器不再静默跳过它们。
`target/eval/report.json` 保留原始尝试、预热、结果及超时前的部分计时,无效尝试不能消失在看似有效的中位数中。启动或构建失败也会生成新的失败报告。会话启动、夹具准备和每次尝试均限时五分钟;渲染器测量另有 Node 期限,比场景配置超时多一秒。服务初始化限时 30 秒,单个 stdio 请求限时五分钟,release 编译限时 60 分钟。清理错误会导致整次运行失败。
## 预算与基线
[`perf/budgets.json`](https://github.com/l0ng-ai/openidea/blob/main/perf/budgets.json) 保存上限(越低越好):
@@ -122,6 +92,4 @@ python perf/compare/bench.py ~/src/some-project --runs 5 --wipe-caches # 冷
每次运行都会用该应用打开项目,等待就绪(窗口出现、日志标记出现后,进程树的 CPU 保持在低位),空闲一段时间后关闭,并记录:到窗口出现和到就绪的时间、应用启动的所有进程(webview、语言服务器、JVM)合计的峰值与空闲内存、CPU 时间、退出耗时和缓存大小。各应用在预热后交替运行,结果输出到 `results/<time>-<project>/`(`report.md`、`results.json`)。
报告保留失败尝试和预热,逐单元格显示有效/尝试次数,并区分不支持的指标与缺失的必需指标。启动超时、崩溃、强制关闭和中断都会使命令失败。退出及清缓存命令有明确期限,观察失败后仍会清理。CPU 平静就绪代理和守护进程排除策略保持不变,详见对比工具 README。
只使用 release 构建;同一可执行文件已有实例在运行时脚本会拒绝执行。公平测量的规则和各平台说明见 [`perf/compare/README.md`](https://github.com/l0ng-ai/openidea/blob/main/perf/compare/README.md)。
+1 -1
Переглянути файл
@@ -78,7 +78,7 @@ Codex 有自己的项目信任设置。如果它禁用了当前项目的 `.codex
在你自己的消息上可以 **编辑**(其后的消息会被替换,已经改动的文件保持不变)或 **撤回消息**。在回复上可以 **复制 Markdown**、**引用回复**、**重新生成回复**,以及 **从此处创建分支对话**,从这一点开始一个新任务。
在已有对话中,打开**模型 › 刷新模型**即可查找新上线的模型,不会发送消息或更改当前选择。如果 agent 无法直接切换,所选模型会保持待应用状态。提供商返回新模型支持的思考强度后,你就可以选择强度。发送下一条消息时,OpenIDEA 会先恢复原会话并应用所选模型和思考强度,再发送消息。如果无法恢复会话,或原会话不接受其中任何一项,OpenIDEA 会还原之前的选择并提示错误,不会发送该消息。
在已有对话中,打开**模型 › 刷新模型**即可查找新上线的模型,不会发送消息或更改当前选择。如果 agent 无法直接切换,所选模型会在下一条消息重新打开原会话时才应用。如果无法恢复会话,或原会话不接受所选模型,OpenIDEA 会还原之前的选择并提示错误,不会发送该消息。
所有内置按键映射中,**聚焦 Agent 输入框** 的默认快捷键都是 macOS 上的 `⌘L`、Windows / Linux 上的 `Ctrl+L`。焦点位于你自己的可输入任务对话中时,无论对话显示在编辑器标签页还是工具窗口中,它都会将焦点移回消息输入框,保留草稿、光标位置和选区;重复按下也不会改变这些内容。它不会发送消息,也不会跳转消息历史。
+7 -51
Переглянути файл
@@ -108,23 +108,15 @@ async function seed(
surface: "new" | "task" = "task",
model = "atlas",
status: AgentTask["status"] = "ready",
catalogOnly = false,
) {
await stubDesktop(page);
await page.evaluate(
async ({ placement, surface, provider, firstTask, secondTask, subagent, model, status, modelId, catalogOnly }) => {
async ({ placement, surface, provider, firstTask, secondTask, subagent, model, status, modelId }) => {
// In-memory sample tasks belong to Vite's browser realm. Static Node imports create a different store and cannot seed the workbench.
const storePath = "/src/features/agents/store.ts";
const store = await import(storePath);
const initialCatalog = {
...provider,
config: provider.config.map((entry) => ({
...entry,
values: entry.values.filter((value) => value.value !== "swift"),
})),
};
const configFor = (model: string) => [
{ ...(catalogOnly && model !== "swift" ? initialCatalog : provider).config[0]!, current: model },
{ ...provider.config[0]!, current: model },
...(provider.thoughtLevels?.[model] ?? []),
];
const tasks = new Map(
@@ -158,10 +150,10 @@ async function seed(
channel = onEvent;
return [...tasks.values()];
};
handlers.agent_providers = () => [catalogOnly ? initialCatalog : provider];
handlers.agent_refresh_models = ({ force }) => ({
handlers.agent_providers = () => [provider];
handlers.agent_refresh_models = () => ({
provider: provider.id,
config: (catalogOnly && !force ? initialCatalog : provider).config,
config: provider.config,
thoughtLevels: provider.thoughtLevels,
refreshing: false,
refreshedAtMs: Date.now(),
@@ -178,15 +170,9 @@ async function seed(
handlers.vcs_branches = () => [];
handlers.agent_set_config = async ({ task: id, option, value }) => {
const previous = tasks.get(String(id))!;
const pendingModel = catalogOnly && option === modelId && value === "swift";
if (pendingModel) {
const { promise, resolve } = Promise.withResolvers<void>();
document.addEventListener("test:chat-model-settings-ready", () => resolve(), { once: true });
await promise;
}
const updated =
option === modelId
? { ...previous, model: pendingModel ? previous.model : String(value), config: configFor(String(value)) }
? { ...previous, model: String(value), config: configFor(String(value)) }
: {
...previous,
config: previous.config.map((entry) =>
@@ -218,7 +204,7 @@ async function seed(
if (surface === "new") store.openHome();
else store.openTask(firstTask.id);
},
{ placement, surface, provider, firstTask, secondTask, subagent, model, status, modelId, catalogOnly },
{ placement, surface, provider, firstTask, secondTask, subagent, model, status, modelId },
);
await expect(box(page)).toBeVisible();
await page.evaluate(() => document.fonts.ready);
@@ -616,33 +602,3 @@ test("New Task discovers uncached model effort before the first prompt", async (
await page.screenshot({ path: testInfo.outputPath("uncached-model-effort.png") });
}
});
test("an existing chat can choose effort for a refreshed model before sending", async ({ workbench: page }) => {
await seed(page, "editor", "task", "atlas", "ready", true);
await box(page).fill(draft);
await expectEffort(page, "Gentle");
await modelButton(page).click();
const swiftModel = page.getByRole("option", { name: /^Swift\b/ });
await expect(swiftModel).toHaveCount(0);
await page.getByRole("button", { name: "Refresh models", exact: true }).click();
await swiftModel.click();
const loading = page.getByRole("status").filter({ hasText: "Loading model settings…" });
const send = page.getByRole("button", { name: "Send", exact: true });
await expect(loading).toBeVisible();
await expect(send).toBeDisabled();
await expect(modelButton(page)).toHaveAttribute("title", /^Model: Atlas\b/);
await page.evaluate(() => document.dispatchEvent(new Event("test:chat-model-settings-ready")));
await expect(loading).toHaveCount(0);
await expect(modelButton(page)).toHaveAttribute("title", /^Model: Swift\b/);
await expectEffort(page, "Quick");
await modelButton(page).click();
const efforts = page.getByRole("radiogroup", { name: "Effort Level", exact: true });
await expect(efforts.getByRole("radio", { name: "Gentle", exact: true })).toHaveCount(0);
await efforts.getByRole("radio", { name: "Thorough", exact: true }).click();
await page.keyboard.press("Escape");
await expectEffort(page, "Thorough");
await expect(send).toBeEnabled();
await expect(box(page)).toHaveText(draft);
await expectNoSubmission(page);
});
-41
Переглянути файл
@@ -76,47 +76,6 @@ test.beforeEach(async ({ workbench: page }) => {
});
});
test("fits a wide graph and saved columns without horizontal scrolling", async ({ workbench: page }) => {
await page.evaluate(async () => {
const module = "/src/features/vcs/logOptions.ts";
const { useLogOptions } = await import(/* @vite-ignore */ module);
useLogOptions.setState({
showColumnHeaders: true,
showHash: true,
showSignature: true,
columnWidths: { author: 400, date: 240 },
});
});
const list = page.getByRole("listbox", { name: "Commits" });
await expect(list.getByRole("separator", { name: "Resize Date column" })).toBeVisible();
for (const width of [1400, 620, 400]) {
await page.setViewportSize({ width, height: 900 });
await expect
.poll(() =>
list.evaluate((element) => {
const header = [...element.querySelectorAll("[data-log-column]")];
const row = [...element.querySelector('[role="option"]')!.children];
const right = element.getBoundingClientRect().right;
return {
fits: element.scrollWidth === element.clientWidth,
aligned: header.every((cell, i) => {
const heading = cell.getBoundingClientRect();
const data = row[i]!.getBoundingClientRect();
return heading.width > 0 && heading.right <= right && Math.abs(heading.right - data.right) < 1;
}),
};
}),
)
.toEqual({ fits: true, aligned: true });
}
await list.hover();
await page.mouse.wheel(450, 450);
await expect.poll(() => list.evaluate((element) => element.scrollTop)).toBeGreaterThan(0);
expect(await list.evaluate((element) => element.scrollLeft)).toBe(0);
});
test("keeps a wide Git graph filled during scrollbar drags and its edges interactive afterwards", async ({
workbench: page,
}) => {
-34
Переглянути файл
@@ -1,34 +0,0 @@
import { expect, test } from "./fixtures";
test("keeps diagnostic text and file counts visible in a narrow Problems pane", async ({ workbench: page }) => {
await page.setViewportSize({ width: 720, height: 760 });
await page.evaluate(async () => {
const projectModule = "/src/platform/project.ts";
const problemsModule = "/src/features/code-insight/problemsStore.ts";
const { useProject } = await import(/* @vite-ignore */ projectModule);
const { applyDiagnosticsEvent } = await import(/* @vite-ignore */ problemsModule);
const root = useProject.getState().project.root;
const path = `${root}/src/features/checkout/shared/services/with-a-long-directory-name/for-order-processing/orders.ts`;
const source = "typescript-eslint-application-rules-with-a-very-long-source-label";
applyDiagnosticsEvent(path, source, [
{
range: { start: { line: 2, col: 2 }, end: { line: 2, col: 9 } },
severity: "error",
source,
message: "Invalid order total",
},
]);
});
await page.getByRole("button", { name: "Problems", exact: true }).click();
const pane = page.locator('[data-toolwindow="problems"]');
await pane.getByRole("tab", { name: /Project Errors/ }).click();
await expect(pane.getByRole("toolbar", { name: "Problems actions" })).toHaveAttribute("aria-orientation", "vertical");
const tree = pane.getByRole("tree", { name: "Problems" });
const count = tree.getByText("1 error", { exact: true });
const message = tree.getByText("Invalid order total", { exact: true });
await expect(count).toBeVisible();
await expect(message).toBeVisible();
await expect.poll(() => message.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true);
await expect.poll(() => tree.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true);
});
-19
Переглянути файл
@@ -1,19 +0,0 @@
import { expect, test } from "./fixtures";
test("gives the project name room before its path in a narrow tree", async ({ workbench: page }) => {
await page.evaluate(async () => {
const storeModule = "/src/features/project-tree/store.ts";
const { useProjectTree } = await import(/* @vite-ignore */ storeModule);
useProjectTree.setState({ name: "checkout-order-processing" });
});
const pane = page.getByRole("region", { name: "Project", exact: true });
await pane.getByRole("button", { name: "Options", exact: true }).click();
await page.getByRole("menuitemcheckbox", { name: "Horizontal Scrolling" }).click();
const tree = pane.getByRole("tree", { name: "Project" });
const name = tree.getByText("checkout-order-processing", { exact: true });
await expect(name).toBeVisible();
await expect.poll(() => name.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true);
await expect.poll(() => tree.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true);
});
-37
Переглянути файл
@@ -1,37 +0,0 @@
import { expect, test } from "./fixtures";
test("keeps the file count visible beside a long directory in the TODO pane", async ({ workbench: page }) => {
await page.setViewportSize({ width: 900, height: 760 });
await page.evaluate(async () => {
const projectModule = "/src/platform/project.ts";
const todoModule = "/src/features/todo/store.ts";
const { useProject } = await import(/* @vite-ignore */ projectModule);
const { useTodos } = await import(/* @vite-ignore */ todoModule);
const directory = "src/features/checkout/shared/services/with-a-long-directory-name/for-order-processing";
const path = `${useProject.getState().project.root}/${directory}/orders.ts`;
useTodos.setState({
scannedOnce: true,
error: null,
scanned: new Map([[path, [{ path, line: 8, col: 3, keyword: "TODO", text: "TODO: validate orders" }]]]),
});
});
await page.getByRole("button", { name: "TODO" }).click();
const pane = page.locator('[data-toolwindow="todo"]');
const toolbar = pane.getByRole("toolbar", { name: "TODO actions" });
await expect(toolbar).toHaveAttribute("aria-orientation", "vertical");
const tree = pane.getByRole("tree", { name: "TODO items" });
const fileName = tree.getByText("orders.ts", { exact: true });
await expect(fileName).toBeVisible();
await expect.poll(() => fileName.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true);
const count = tree.getByText("1 item", { exact: true });
await expect(count).toBeVisible();
await expect
.poll(() =>
count.evaluate(
(element) =>
element.getBoundingClientRect().right <= element.closest('[role="tree"]')!.getBoundingClientRect().right,
),
)
.toBe(true);
});
+36 -69
Переглянути файл
@@ -7,8 +7,6 @@ import { join } from "node:path";
import { track } from "../lib/measure.ts";
import { normalizePath, type EvalScenario, type Measured } from "../lib/scenario.ts";
import type { Session } from "../lib/session.ts";
import { renameFinished, renameResult, type RenameStep } from "../lib/renameObservation.ts";
import type { Renamed } from "../../src/bindings.ts";
const SRC = "src/main/java/com/example/orders";
const TEST = "src/test/java/com/example/orders";
@@ -19,7 +17,7 @@ const LONG_TIMEOUT = 60_000;
interface ProbeWindow {
__openideaPerf: {
editorState(): { doc: number; path: string; head: number; line: number; col: number; word: string } | null;
editorState(): { path: string; head: number; line: number; word: string } | null;
editorText(): string | null;
setCursor(offset: number): void;
insertAfter(after: string, text: string): number;
@@ -27,8 +25,6 @@ interface ProbeWindow {
completionPending(): boolean;
diagnostics(): Array<{ line: number; severity: string; message: string }>;
lineAtY(y: number): number;
openFileForDiagnostics(path: string, source: string): Promise<number>;
diagnosticsPublished(generation: number): boolean;
};
}
@@ -377,21 +373,10 @@ function diagnosticsOnOpen(project: string, id: string, title: string, file: str
async setup() {},
async step(s): Promise<Measured> {
const timing = await track(s.page, {
run: async (arg) => {
const w = window as unknown as ProbeWindow;
arg.generation = await w.__openideaPerf.openFileForDiagnostics(arg.path, "jdtls");
},
arg: { path: join(s.root, file), generation: 0 },
first: (arg) => {
const w = window as unknown as ProbeWindow;
return (
w.__openideaPerf.diagnosticsPublished(arg.generation) && !!document.querySelector(".cm-content .cm-line")
);
},
done: (arg) => {
const w = window as unknown as ProbeWindow;
return w.__openideaPerf.diagnosticsPublished(arg.generation);
},
openFile: join(s.root, file),
arg: null,
first: () => !!document.querySelector(".cm-content .cm-line"),
done: () => true,
signature: problems,
settleMs: 3000,
timeoutMs: TIMEOUT,
@@ -529,19 +514,12 @@ function quickDoc(project: string, id: string, title: string, at: Place): EvalSc
};
}
interface RenameAnswer {
edit: { files: Array<{ path?: string; edits?: Array<{ range: { start: { line: number } }; new_text: string }> }> };
}
/** Rename in place to `newName`, then ↵: every edit it makes (a preview is left unapplied). */
function rename(
project: string,
id: string,
title: string,
at: Place,
newName: string,
mode: RenameStep["mode"],
): EvalScenario {
const prepared = new WeakMap<
Session,
{ doc: number; path: string; pos: { line: number; col: number }; original: string }
>();
function rename(project: string, id: string, title: string, at: Place, newName: string): EvalScenario {
return {
id,
title,
@@ -550,39 +528,23 @@ function rename(
conditions: ["warm"],
async setup(s) {
await reach(s, at);
const before = await s.page.evaluate(() => {
const w = window as unknown as ProbeWindow;
const state = w.__openideaPerf.editorState();
const original = w.__openideaPerf.editorText();
if (!state || original === null) throw new Error("no active editor before rename");
return { doc: state.doc, path: state.path, pos: { line: state.line, col: state.col }, original };
});
prepared.set(s, before);
await s.keepText();
await s.runAction("refactor.rename");
await s.page.waitForSelector(".cm-lsp-inplace-primary", { timeout: TIMEOUT });
await s.page.keyboard.type(newName);
},
async step(s): Promise<Measured> {
const before = prepared.get(s);
if (!before) throw new Error("rename was not prepared");
const scope = s.renameObservations.begin({ doc: before.doc, pos: before.pos, newName });
const arg: RenameStep = {
scope,
root: s.root,
path: before.path,
original: before.original,
oldName: at.word,
newName,
mode,
answer: null,
const answered = (newName: string) => {
if (document.querySelector('[data-testid="refactor-preview"]')) return true;
if (document.querySelector(".cm-lsp-hint:not([data-pending]):not(.cm-lsp-inplace-hint)")) return true;
return (
!document.querySelector(".cm-lsp-inplace") &&
!!(window as unknown as ProbeWindow).__openideaPerf.editorText()?.includes(newName)
);
};
const timing = await track(s.page, {
run: async (arg) => {
const w = window as unknown as { __openideaEvalRenameAnswer(scope: number): Promise<Renamed> };
const content = document.querySelector(".cm-content");
if (!content) throw new Error("no editor for rename");
content.dispatchEvent(
run: () =>
document.querySelector(".cm-content")?.dispatchEvent(
new KeyboardEvent("keydown", {
key: "Enter",
code: "Enter",
@@ -590,17 +552,25 @@ function rename(
bubbles: true,
cancelable: true,
}),
);
arg.answer = await w.__openideaEvalRenameAnswer(arg.scope);
},
arg,
first: renameFinished,
done: renameFinished,
),
arg: newName,
first: answered,
done: answered,
timeoutMs: TIMEOUT,
});
const answer = s.renameObservations.completed(scope) as Renamed | null;
if (!answer) throw new Error("rename did not receive a current successful response");
return { timing, ...renameResult(s.root, answer, newName) };
// The preview only counts per file: where the name lands is in the answer it shows. A server
// may merge nearby occurrences into one edit, so every line of its new text counts.
const answer = s.lastAnswer.get("lsp_rename") as RenameAnswer | undefined;
const changes = (answer?.edit.files ?? []).flatMap((f) =>
(f.edits ?? []).flatMap((e) =>
e.new_text
.split("\n")
.flatMap((l, i) =>
l.includes(newName) ? [`${normalizePath(s.root, f.path!)}:${e.range.start.line + i + 1}`] : [],
),
),
);
return { timing, results: { changes } };
},
};
}
@@ -778,7 +748,6 @@ export const JAVA_SCENARIOS: EvalScenario[] = [
"Rename: method used across files",
{ file: `${SRC}/Order.java`, line: "public long totalCents() {", word: "totalCents" },
"orderTotalCents",
"preview",
),
rename(
APP,
@@ -786,7 +755,6 @@ export const JAVA_SCENARIOS: EvalScenario[] = [
"Rename: local variable",
{ file: BOOK, line: "Order order = new Order(customer, product, quantity, unitPriceCents);", word: "order" },
"placedOrder",
"applied",
),
declaration(
@@ -869,6 +837,5 @@ export const JAVA_SCENARIOS: EvalScenario[] = [
"Rename: entity method used across controllers and tests",
{ file: `${PET}/owner/Owner.java`, line: "public void addVisit(Integer petId, Visit visit) {", word: "addVisit" },
"recordVisit",
"preview",
),
];
-29
Переглянути файл
@@ -1,29 +0,0 @@
import { spawnSync } from "node:child_process";
import { resolve } from "node:path";
import { describe, expect, test } from "vitest";
const runner = resolve(import.meta.dirname, "../run.ts");
describe("eval CLI preflight (no app builds)", () => {
test.each([
[["--condition", "hot"], /--condition must be warm or cold/],
[["--only", "java.app,unknown"], /no scenario matches unknown/],
[["--only", "java.app,"], /empty selector/],
[["--only", "java.app.usages", "--condition", "cold"], /no compatible scenario/],
[["--runs", "0"], /--runs/],
[["--runs", "Infinity"], /--runs/],
[["--runs", "1.5"], /--runs/],
[["--warmup", "NaN"], /--warmup/],
[["--warmup=-1"], /--warmup/],
] as const)("rejects %j before build/start", (args, message) => {
const result = spawnSync(process.execPath, [runner, ...args], {
encoding: "utf8",
timeout: 15_000,
env: { ...process.env, PATH: "", OPENIDEA_SERVER: "/nonexistent/eval-preflight-server" },
});
expect(result.error).toBeUndefined();
expect(result.status).not.toBe(0);
expect(result.stderr).toMatch(message);
expect(result.stdout).not.toContain("Building openidea-server");
});
});
-91
Переглянути файл
@@ -1,91 +0,0 @@
import { describe, expect, test } from "vitest";
import { RenameObservations } from "./commandObservation.ts";
const target = { doc: 7, pos: { line: 2, col: 8 }, newName: "renamed" };
const answer = { edit: { files: [] }, incomplete: null };
function deferred() {
let resolve!: (value: unknown) => void;
// The harness TypeScript project targets ES2023.
const promise = new Promise<unknown>((done) => {
resolve = done;
});
return { promise, resolve };
}
describe("rename command observations", () => {
test("consumes only a matching command in the current operation", async () => {
const capture = new RenameObservations();
const scope = capture.begin(target);
await capture.invoke("lsp_rename", { ...target, doc: 8, request: 1 }, async () => answer);
await capture.invoke("lsp_rename", { ...target, newName: "other", request: 2 }, async () => answer);
await capture.invoke("lsp_rename", { ...target, pos: { line: 3, col: 8 }, request: 3 }, async () => answer);
expect(capture.completed(scope)).toBeNull();
await capture.invoke("lsp_rename", { ...target, request: 4 }, async () => answer);
expect(await capture.wait(scope)).toEqual(answer);
});
test("reset and failure cannot supply a preceding success", async () => {
const capture = new RenameObservations();
const previous = capture.begin(target);
await capture.invoke("lsp_rename", { ...target, request: 1 }, async () => answer);
capture.reset();
expect(capture.completed(previous)).toBeNull();
await expect(capture.wait(previous)).rejects.toThrow("operation expired");
const current = capture.begin(target);
const waiting = capture.wait(current);
const rejected = expect(waiting).rejects.toThrow("rename failed");
await expect(
capture.invoke("lsp_rename", { ...target, request: 2 }, async () => {
throw new Error("rename failed");
}),
).rejects.toThrow("rename failed");
await rejected;
expect(capture.completed(current)).toBeNull();
});
test("a failed retry clears a success in the same operation", async () => {
const capture = new RenameObservations();
const scope = capture.begin(target);
await capture.invoke("lsp_rename", { ...target, request: 1 }, async () => answer);
expect(capture.completed(scope)).toEqual(answer);
await expect(
capture.invoke("lsp_rename", { ...target, request: 2 }, async () => {
throw new Error("retry failed");
}),
).rejects.toThrow("retry failed");
expect(capture.completed(scope)).toBeNull();
await expect(capture.wait(scope)).rejects.toThrow("retry failed");
});
test("a delayed result from before reset cannot win over a new request", async () => {
const capture = new RenameObservations();
capture.begin(target);
const old = deferred();
const sending = capture.invoke("lsp_rename", { ...target, request: 1 }, () => old.promise);
capture.reset();
const current = capture.begin(target);
old.resolve(answer);
await sending;
expect(capture.completed(current)).toBeNull();
const fresh = { ...answer, preview: true };
await capture.invoke("lsp_rename", { ...target, request: 2 }, async () => fresh);
expect(await capture.wait(current)).toEqual(fresh);
});
test("a superseded in-flight request cannot overwrite the latest failure", async () => {
const capture = new RenameObservations();
const scope = capture.begin(target);
const old = deferred();
const sending = capture.invoke("lsp_rename", { ...target, request: 1 }, () => old.promise);
await expect(
capture.invoke("lsp_rename", { ...target, request: 2 }, async () => {
throw new Error("latest failed");
}),
).rejects.toThrow("latest failed");
old.resolve(answer);
await sending;
expect(capture.completed(scope)).toBeNull();
await expect(capture.wait(scope)).rejects.toThrow("latest failed");
});
});
-74
Переглянути файл
@@ -1,74 +0,0 @@
/** Command capture shared by the Session relay and rename's measured operation. */
export interface RenameTarget {
doc: number;
pos: { line: number; col: number };
newName: string;
}
interface Operation {
scope: number;
target: RenameTarget;
request: number;
result: { ok: true; value: unknown } | { ok: false; error: unknown } | null;
listeners: Array<{ resolve(value: unknown): void; reject(error: unknown): void }>;
}
export class RenameObservations {
private generation = 0;
private operation: Operation | null = null;
begin(target: RenameTarget): number {
this.reset();
this.operation = { scope: this.generation, target, request: 0, result: null, listeners: [] };
return this.generation;
}
reset() {
this.generation++;
for (const listener of this.operation?.listeners ?? []) listener.reject(new Error("rename operation expired"));
this.operation = null;
}
/** Captures the invocation, not just its answer: old requests retain their original scope. */
async invoke<T>(cmd: string, args: unknown, send: () => Promise<T>): Promise<T> {
const op = this.operation;
const actual = args as Partial<RenameTarget> | null;
const matching =
cmd === "lsp_rename" &&
op &&
actual &&
actual.doc === op.target.doc &&
actual.newName === op.target.newName &&
actual.pos?.line === op.target.pos.line &&
actual.pos?.col === op.target.pos.col;
const request = matching ? ++op.request : 0;
if (matching) op.result = null;
try {
const value = await send();
if (matching && this.operation === op && op.request === request) {
op.result = { ok: true, value };
for (const listener of op.listeners.splice(0)) listener.resolve(value);
}
return value;
} catch (error) {
if (matching && this.operation === op && op.request === request) {
op.result = { ok: false, error };
for (const listener of op.listeners.splice(0)) listener.reject(error);
}
throw error;
}
}
completed(scope: number): unknown | null {
const op = this.operation;
return op?.scope === scope && op.result?.ok ? op.result.value : null;
}
wait(scope: number): Promise<unknown> {
const op = this.operation;
if (!op || op.scope !== scope) return Promise.reject(new Error("rename operation expired"));
if (op.result) return op.result.ok ? Promise.resolve(op.result.value) : Promise.reject(op.result.error);
// ES2023 harnesses cannot use Promise.withResolvers().
return new Promise((resolve, reject) => op.listeners.push({ resolve, reject }));
}
}
+2 -10
Переглянути файл
@@ -37,11 +37,7 @@ export function pinnedTools(file: string): Record<string, string> {
function which(cmd: string): string | null {
try {
const found = execFileSync(process.platform === "win32" ? "where" : "which", [cmd], {
encoding: "utf8",
timeout: 10_000,
killSignal: "SIGKILL",
})
const found = execFileSync(process.platform === "win32" ? "where" : "which", [cmd], { encoding: "utf8" })
.split("\n")[0]!
.trim();
return found ? realpathSync(found) : null;
@@ -73,11 +69,7 @@ function jdtlsVersion(): string | null {
function javaVersion(): string | null {
const home = process.env.JAVA_HOME;
const java = home ? join(home, "bin", process.platform === "win32" ? "java.exe" : "java") : "java";
const r = spawnSync(java, ["-XshowSettings:properties", "-version"], {
encoding: "utf8",
timeout: 10_000,
killSignal: "SIGKILL",
});
const r = spawnSync(java, ["-XshowSettings:properties", "-version"], { encoding: "utf8" });
const props = `${r.stdout ?? ""}${r.stderr ?? ""}`;
const version = /java\.runtime\.version = (\S+)/.exec(props)?.[1];
const vendor = /java\.vendor = (.+)/.exec(props)?.[1]?.trim();
-77
Переглянути файл
@@ -1,77 +0,0 @@
// @vitest-environment node
import { chromium, type Browser, type Page } from "@playwright/test";
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
import { track } from "./measure.ts";
let browser: Browser;
let page: Page;
beforeAll(async () => {
browser = await chromium.launch({ headless: true });
});
beforeEach(async () => {
page = await browser.newPage();
await page.setContent('<div role="dialog">Previous dialog</div><div id="result">Previous result</div>');
await page.evaluate(() => {
Object.assign(window, {
__openideaPerf: {
editorState: () => null,
runAction: async () => false,
},
});
});
});
afterEach(async () => {
await page.close();
});
afterAll(async () => {
await browser.close();
});
const existingResult = () => document.querySelector("#result") !== null;
describe("tracking the current action", () => {
it("rejects an action that declines to run even with an old result visible", async () => {
await expect(
track(page, { action: "unavailable", arg: null, first: existingResult, done: existingResult, timeoutMs: 1000 }),
).rejects.toThrow(/did not run/);
});
it("cannot report success before an asynchronous action later rejects", async () => {
await expect(
track(page, {
// Real browser frames exercise ordering against track's rAF observer; no elapsed-time guess.
run: () =>
new Promise((_, reject) => {
requestAnimationFrame(() => requestAnimationFrame(() => reject(new Error("operation failed"))));
}),
arg: null,
first: existingResult,
done: existingResult,
timeoutMs: 1000,
}),
).rejects.toThrow("operation failed");
});
it("waits for successful action completion and observes its current result", async () => {
const timing = await track(page, {
run: () =>
new Promise<void>((resolve) => {
requestAnimationFrame(() => {
document.querySelector("#result")!.textContent = "Current result";
requestAnimationFrame(() => {
document.querySelector("#result")!.setAttribute("data-completed", "true");
resolve();
});
});
}),
arg: null,
first: () => document.querySelector("#result")?.textContent === "Current result",
done: () => document.querySelector("#result")?.textContent === "Current result",
timeoutMs: 1000,
});
expect(await page.locator("#result").textContent()).toBe("Current result");
expect(timing.completeMs).toBeGreaterThanOrEqual(timing.firstResultMs);
expect(timing.feedbackMs).toBeGreaterThanOrEqual(timing.firstResultMs);
expect(await page.locator("#result").getAttribute("data-completed")).toBe("true");
});
});
+14 -46
Переглянути файл
@@ -3,7 +3,6 @@
* what the user would see. A condition true at the start of a frame is painted by it.
*/
import type { Page } from "@playwright/test";
import { withDeadline } from "../../perf/lib/lifecycle.ts";
/**
* A check of the page, run in it every frame: self-contained (it is re-created from its
@@ -56,7 +55,7 @@ export class TimeoutError extends Error {
}
export async function track<A>(page: Page, spec: TrackSpec<A>): Promise<Tracked> {
const operation = page.evaluate(
const r = await page.evaluate(
({ action, actionArg, openFile, run, arg, first, done, feedback, signature, settleMs, timeoutMs }) => {
const w = window as unknown as {
__openideaPerf: {
@@ -76,57 +75,26 @@ export async function track<A>(page: Page, spec: TrackSpec<A>): Promise<Tracked>
let lastSig: string | null = null;
let lastChange = 0;
const before = w.__openideaPerf.editorState();
const feedbackSelector = '.cm-lsp-hint, [data-testid="usages-popup"], [role="dialog"], [role="listbox"]';
const beforeFeedback = new Map<Element, { text: string | null; loading: string | null; busy: string | null }>();
for (const el of document.querySelectorAll(feedbackSelector)) {
if (el.getClientRects().length) {
beforeFeedback.set(el, {
text: el.textContent,
loading: el.getAttribute("data-loading"),
busy: el.getAttribute("aria-busy"),
});
}
}
const visible = (sel: string) =>
[...document.querySelectorAll(sel)].some((el) => (el as HTMLElement).getClientRects().length > 0);
const anyFeedback = () => {
for (const el of document.querySelectorAll(feedbackSelector)) {
if (!el.getClientRects().length) continue;
const previous = beforeFeedback.get(el);
if (
!previous ||
previous.text !== el.textContent ||
previous.loading !== el.getAttribute("data-loading") ||
previous.busy !== el.getAttribute("aria-busy")
)
return true;
}
if (visible('.cm-lsp-hint, [data-testid="usages-popup"], [role="dialog"], [role="listbox"]')) return true;
const now = w.__openideaPerf.editorState();
if ((now?.path ?? null) !== (before?.path ?? null) || (now && before && now.head !== before.head)) return true;
return checks.feedback?.(arg, before) ?? false;
};
const times: { feedbackMs?: number; firstResultMs?: number; completeMs?: number } = {};
const t0 = performance.now();
let completed = false;
let failed: string | null = null;
const started = Promise.resolve().then<unknown>(() =>
run
? make(run)!(arg, before)
: openFile
? w.__openideaPerf.openFile(openFile)
: w.__openideaPerf.runAction(action!, actionArg),
);
void started.then(
(value) => {
if (!run && !openFile && value !== true) failed = "action did not run";
else completed = true;
},
(error: unknown) => {
failed = error instanceof Error ? error.message : String(error);
},
);
let failed: unknown = null;
const started = run
? new Promise((resolve) => resolve(make(run)!(arg, before)))
: openFile
? w.__openideaPerf.openFile(openFile)
: w.__openideaPerf.runAction(action!, actionArg);
void started.catch((e: unknown) => (failed = e));
return new Promise<{ times: typeof times; timedOut: boolean; error: string | null }>((resolve) => {
const tick = () => {
const t = performance.now() - t0;
if (failed !== null) return resolve({ times, timedOut: false, error: failed });
try {
if (times.feedbackMs === undefined && anyFeedback()) times.feedbackMs = t;
if (times.firstResultMs === undefined && checks.first(arg, before)) times.firstResultMs = t;
@@ -138,7 +106,7 @@ export async function track<A>(page: Page, spec: TrackSpec<A>): Promise<Tracked>
}
}
const settled = !sign || t - lastChange >= (settleMs ?? 0);
if (completed && times.firstResultMs !== undefined && settled && checks.done(arg, before)) {
if (times.firstResultMs !== undefined && settled && checks.done(arg, before)) {
// Session.reset waits out the time in which invoking it again widens it.
if (action === "find.showUsages")
(window as unknown as { __openideaEvalShowUsagesAt?: number }).__openideaEvalShowUsagesAt =
@@ -150,6 +118,7 @@ export async function track<A>(page: Page, spec: TrackSpec<A>): Promise<Tracked>
} catch (e) {
return resolve({ times, timedOut: false, error: String(e) });
}
if (failed) return resolve({ times, timedOut: false, error: String((failed as Error).message ?? failed) });
if (t > timeoutMs) return resolve({ times, timedOut: true, error: null });
requestAnimationFrame(tick);
};
@@ -170,9 +139,8 @@ export async function track<A>(page: Page, spec: TrackSpec<A>): Promise<Tracked>
timeoutMs: spec.timeoutMs,
},
);
const r = await withDeadline(operation, spec.timeoutMs + 1000, "page measurement");
const what = spec.action ?? (spec.openFile ? `open ${spec.openFile}` : "step");
if (r.error !== null) throw new Error(`${what}: ${r.error}`);
if (r.error) throw new Error(`${what}: ${r.error}`);
if (r.timedOut) {
const seen =
r.times.firstResultMs !== undefined
-26
Переглянути файл
@@ -1,26 +0,0 @@
// @vitest-environment node
import { expect, test } from "vitest";
import { launchBrowser } from "../../perf/lib/lifecycle.ts";
import { track } from "./measure.ts";
test("track times out on Node's clock when animation frames stop", { timeout: 20_000 }, async () => {
const runtime = await launchBrowser({ headless: true });
try {
const page = await runtime.browser.newPage();
await page.evaluate(() => {
// Install the otherwise undeclared probe consumed by the serialized measurement.
const w = window as unknown as { __openideaPerf: unknown };
w.__openideaPerf = {
editorState: () => null,
runAction: async () => true,
};
window.requestAnimationFrame = () => 0;
});
// The platform-clock boundary is the regression; a fake Node clock cannot drive Chromium.
await expect(
track(page, { action: "fixture.action", arg: null, first: () => false, done: () => false, timeoutMs: 20 }),
).rejects.toThrow("page measurement timed out");
} finally {
await runtime.close();
}
});
-104
Переглянути файл
@@ -1,104 +0,0 @@
import { afterEach, expect, test } from "vitest";
import { renameFinished, renameResult, type RenameStep } from "./renameObservation.ts";
import type { Renamed } from "../../src/bindings.ts";
const original = "int order = 1;\nuse(order);";
const answer: Renamed = {
edit: {
files: [
{
kind: "edit",
path: "/p/A.java",
edits: [
{ range: { start: { line: 0, col: 4 }, end: { line: 0, col: 9 } }, new_text: "placedOrder" },
{ range: { start: { line: 1, col: 4 }, end: { line: 1, col: 9 } }, new_text: "placedOrder" },
],
},
],
},
incomplete: null,
};
const step: RenameStep = {
scope: 1,
path: "/p/A.java",
root: "/p",
oldName: "order",
newName: "placedOrder",
original,
mode: "applied",
answer,
};
let text = original;
let state = { path: step.path, word: "order", head: 9, line: 0 };
const w = window as unknown as { __openideaPerf?: unknown };
function fixture() {
w.__openideaPerf = { editorText: () => text, editorState: () => state };
document.body.innerHTML = '<div class="cm-content"><div class="cm-line"></div></div>';
}
afterEach(() => {
document.body.innerHTML = "";
delete w.__openideaPerf;
text = original;
state = { path: step.path, word: "order", head: 9, line: 0 };
});
test("a successful response and typed new name are not an applied rename", () => {
fixture();
document.body.insertAdjacentHTML("beforeend", '<span class="cm-lsp-hint">Rename failed</span>');
text = original.replace("order", "placedOrder");
expect(renameFinished(step)).toBe(false);
text = original.replaceAll("order", "placedOrder");
state = { ...state, word: "placedOrder", head: 14 };
expect(renameFinished(step)).toBe(false);
document.querySelector(".cm-lsp-hint")!.remove();
expect(renameFinished(step)).toBe(true);
expect(renameFinished({ ...step, answer: null })).toBe(false);
state = { ...state, path: "/p/other.java" };
expect(renameFinished(step)).toBe(false);
});
test("preview requires the matching title, files and counts without applying text", () => {
fixture();
const preview: RenameStep = { ...step, mode: "preview" };
document.body.insertAdjacentHTML(
"beforeend",
'<div role="dialog"><h2>Rename \'order\' to \'placedOrder\'</h2><ul data-testid="refactor-preview"><li><span title="A.java">A.java</span><span>2 occurrences</span></li></ul></div>',
);
expect(renameFinished(preview)).toBe(true);
expect(renameFinished(step)).toBe(false);
text = original.replaceAll("order", "placedOrder");
expect(renameFinished(preview)).toBe(false);
text = original;
document.querySelector("[title]")!.setAttribute("title", "other.java");
expect(renameFinished(preview)).toBe(false);
});
test("incomplete responses retain warning identity instead of claiming local application", () => {
fixture();
text = original.replaceAll("order", "placedOrder");
state = { ...state, word: "placedOrder", head: 14 };
expect(renameFinished({ ...step, answer: { ...answer, incomplete: "indexing" } })).toBe(false);
const incomplete: Renamed = { ...answer, incomplete: "indexing" };
expect(renameResult("/p", incomplete, "placedOrder")).toEqual({
results: { changes: ["A.java:1", "A.java:2"] },
degraded: "Rename may be incomplete: indexing",
});
text = original;
document.body.insertAdjacentHTML(
"beforeend",
'<div role="dialog"><h2>Rename \'order\' to \'placedOrder\'</h2><div role="note">May be incomplete: the language server is still indexing</div><ul data-testid="refactor-preview"><li><span title="A.java">A.java</span><span>2 occurrences</span></li></ul></div>',
);
expect(renameFinished({ ...step, answer: incomplete })).toBe(true);
expect(renameResult("/p", answer, "placedOrder").degraded).toBeNull();
});
test("an incomplete empty answer reports degradation only with its warning, never a terminal error", () => {
fixture();
const incomplete: Renamed = { edit: { files: [] }, incomplete: "indexing" };
document.body.insertAdjacentHTML("beforeend", '<span class="cm-lsp-hint">Rename failed</span>');
expect(renameFinished({ ...step, answer: incomplete })).toBe(false);
document.querySelector(".cm-lsp-hint")!.textContent = "May be incomplete: the language server is still indexing";
expect(renameFinished({ ...step, answer: incomplete })).toBe(true);
expect(renameResult("/p", incomplete, "placedOrder").degraded).toBe("Rename may be incomplete: indexing");
expect(renameFinished({ ...step, answer: { edit: { files: [] }, incomplete: null } })).toBe(false);
});
-121
Переглянути файл
@@ -1,121 +0,0 @@
import { normalizePath } from "./scenario.ts";
import type { Renamed } from "../../src/bindings.ts";
export interface RenameStep {
scope: number;
root: string;
path: string;
original: string;
oldName: string;
newName: string;
mode: "preview" | "applied";
answer: Renamed | null;
}
/** Self-contained: track serializes this check into the measured page. */
export function renameFinished(arg: RenameStep): boolean {
const answer = arg.answer;
if (!answer || document.querySelector(".cm-lsp-inplace")) return false;
type ProbeWindow = {
__openideaPerf: {
editorText(): string | null;
editorState(): { path: string; head: number; word: string } | null;
};
};
const w = window as unknown as ProbeWindow;
const probe = w.__openideaPerf;
const state = probe.editorState();
const text = probe.editorText();
if (state?.path !== arg.path || text === null) return false;
if (!answer.edit.files.length) {
return (
text === arg.original &&
!!answer.incomplete &&
/may be incomplete/i.test(document.querySelector(".cm-lsp-hint:not([data-pending])")?.textContent ?? "")
);
}
if (document.querySelector(".cm-lsp-hint:not([data-pending]):not(.cm-lsp-inplace-hint)")) return false;
const preview = document.querySelector('[data-testid="refactor-preview"]');
if (arg.mode === "preview" || answer.incomplete) {
if (!preview || text !== arg.original) return false;
const dialog = preview.closest('[role="dialog"]');
const title = dialog?.querySelector('h1, h2, [data-slot="dialog-title"]')?.textContent ?? dialog?.textContent ?? "";
if (!title.includes(`'${arg.oldName}'`) || !title.includes(`'${arg.newName}'`)) return false;
if (answer.incomplete && !dialog?.querySelector('[role="note"]')) return false;
const entries = new Map<string, { edits: number; operation?: string; to?: string }>();
for (const file of answer.edit.files) {
const path = file.kind === "rename" ? file.from : file.path;
let entry = entries.get(path);
if (!entry) entries.set(path, (entry = { edits: 0 }));
if (file.kind === "edit") entry.edits += file.edits.length;
else {
entry.operation = file.kind;
if (file.kind === "rename") entry.to = file.to;
}
}
const expected = [...entries].filter(([, entry]) => entry.edits || entry.operation);
const rows = [...preview.querySelectorAll("li")];
return (
rows.length === expected.length &&
expected.every(([path, entry]) => {
const relative = path.startsWith(arg.root + "/") ? path.slice(arg.root.length + 1) : path;
const row = rows.find((row) =>
[...row.querySelectorAll("[title]")].some((el) => el.getAttribute("title") === relative),
);
if (!row) return false;
const count = `${entry.edits} ${entry.edits === 1 ? "occurrence" : "occurrences"}`;
if (entry.edits && ![...row.querySelectorAll("span")].some((el) => el.textContent === count)) return false;
if (entry.operation === "rename")
return !!entry.to && !!row.textContent?.includes(`→ ${entry.to.slice(entry.to.lastIndexOf("/") + 1)}`);
return !entry.operation || !!row.textContent?.includes(entry.operation);
})
);
}
if (preview || answer.preview || answer.edit.files.some((file) => file.kind !== "edit" || file.path !== arg.path))
return false;
const edits = answer.edit.files.flatMap((file) => (file.kind === "edit" ? file.edits : []));
if (!edits.length) return false;
const lines = arg.original.split("\n");
const offset = (pos: { line: number; col: number }) => {
if (pos.line < 0 || pos.line >= lines.length || pos.col < 0 || pos.col > lines[pos.line]!.length) return -1;
let at = pos.col;
for (let i = 0; i < pos.line; i++) at += lines[i]!.length + 1;
return at;
};
const changes = edits
.map((edit) => ({ from: offset(edit.range.start), to: offset(edit.range.end), text: edit.new_text }))
.sort((a, b) => b.from - a.from);
let expected = arg.original;
let previous = expected.length;
for (const change of changes) {
if (change.from < 0 || change.to < change.from || change.to > previous) return false;
expected = expected.slice(0, change.from) + change.text + expected.slice(change.to);
previous = change.from;
}
// Exact edit application excludes the temporary, optimistically typed in-place name.
return (
expected !== arg.original &&
text === expected &&
state.word === arg.newName &&
state.head >= 0 &&
state.head <= text.length
);
}
export function renameResult(root: string, answer: Renamed, newName: string) {
const changes = answer.edit.files.flatMap((file) =>
file.kind === "edit"
? file.edits.flatMap((edit) =>
edit.new_text
.split("\n")
.flatMap((line, i) =>
line.includes(newName) ? [`${normalizePath(root, file.path)}:${edit.range.start.line + i + 1}`] : [],
),
)
: [],
);
return {
results: { changes },
degraded: answer.incomplete ? `Rename may be incomplete: ${answer.incomplete}` : null,
};
}
-37
Переглянути файл
@@ -1,37 +0,0 @@
import { describe, expect, test } from "vitest";
import { planSelection } from "./selection.ts";
const scenarios = [
{ id: "java.a.one", title: "One", conditions: ["warm", "cold"] as const },
{ id: "java.b.two", title: "Two", conditions: ["warm"] as const },
];
describe("eval workload planning", () => {
test("full and deduplicated subset plans are independent of collected outcomes", () => {
expect(planSelection(scenarios, {}).expected).toHaveLength(3);
const plan = planSelection(scenarios, { only: " java.a, java.a.one ", condition: "cold" });
expect(plan.selected).toEqual([scenarios[0]]);
expect(plan.expected).toEqual([{ scenario: "java.a.one", title: "One", condition: "cold" }]);
});
test.each([
{ condition: "hot" },
{ only: "java.a,unknown" },
{ only: "" },
{ only: "java.a," },
{ only: "java.b", condition: "cold" },
{ only: "java.a,java.b", condition: "cold" },
{ runs: "0" },
{ runs: "NaN" },
{ runs: "Infinity" },
{ runs: "1.5" },
{ runs: "9007199254740992" },
{ warmup: "-1" },
{ warmup: "Infinity" },
{ warmup: "0.5" },
])("rejects invalid selection/counts %j", (args) => {
expect(() => planSelection(scenarios, args)).toThrow();
});
test("rejects zero work", () => {
expect(() => planSelection([], {})).toThrow(/no compatible/);
});
});
-42
Переглянути файл
@@ -1,42 +0,0 @@
import { countOption } from "../../perf/lib/options.ts";
import type { Condition } from "./verdict.ts";
interface Scenario {
id: string;
title: string;
conditions: readonly Condition[];
}
export interface ExpectedOutcome {
scenario: string;
title: string;
condition: Condition;
}
export function planSelection<T extends Scenario>(
scenarios: readonly T[],
args: { only?: string; condition?: string; runs?: string; warmup?: string },
) {
const runs = countOption("runs", args.runs ?? "3", 1);
const warmup = countOption("warmup", args.warmup ?? "1", 0);
if (args.condition !== undefined && args.condition !== "warm" && args.condition !== "cold")
throw new Error("--condition must be warm or cold");
const condition = args.condition as Condition | undefined;
const selectors = args.only?.split(",").map((s) => s.trim());
const matches = (s: T, selector: string) => s.id === selector || s.id.startsWith(`${selector}.`);
for (const selector of selectors ?? []) {
if (!selector) throw new Error("--only contains an empty selector");
const matching = scenarios.filter((s) => matches(s, selector));
if (!matching.length) throw new Error(`no scenario matches ${selector} (see --list)`);
if (!matching.some((s) => s.conditions.some((c) => !condition || c === condition)))
throw new Error(`no compatible scenario for selector ${selector} under ${condition}`);
}
const selected = scenarios.filter((s) => !selectors || selectors.some((selector) => matches(s, selector)));
const expected: ExpectedOutcome[] = selected.flatMap((s) =>
s.conditions
.filter((c) => !condition || c === condition)
.map((c) => ({ scenario: s.id, title: s.title, condition: c })),
);
if (!expected.length) throw new Error("no compatible scenarios selected");
return { selected, expected, runs, warmup, condition };
}
+51 -71
Переглянути файл
@@ -8,12 +8,9 @@ import { homedir, tmpdir } from "node:os";
import { join, sep } from "node:path";
import type { Browser, BrowserContext, Page } from "@playwright/test";
import { installInPage } from "../../perf/lib/inpage.ts";
import { withDeadline } from "../../perf/lib/lifecycle.ts";
import { Server } from "../../smoke/server.ts";
import { copyProject } from "./projects.ts";
import { installTauriShim, type ShimWindow } from "../../smoke/tauriShim.ts";
import { RenameObservations } from "./commandObservation.ts";
import { openFileMeasured } from "../../perf/lib/editing.ts";
/** How long after its answer Show Usages invoked again widens it (`HINT_MS` in code-insight/usages.ts), plus a margin. */
const SHOW_USAGES_HINT_MS = 4200;
@@ -128,11 +125,11 @@ export class Session {
private server!: Server;
private relayQueue: Promise<unknown> = Promise.resolve();
private pendingNotes: Array<[kind: "channel" | "event", a: unknown, b: unknown]> = [];
readonly renameObservations = new RenameObservations();
/** The last answer to each command that succeeded, for what the UI only summarises. */
readonly lastAnswer = new Map<string, unknown>();
/** Editors changed by a scenario: path → the text to put back. */
private readonly edited = new Map<string, string>();
readonly pageErrors: string[] = [];
private closed = false;
private constructor(opts: SessionOptions) {
this.root = join(opts.workDir, "projects", opts.fixture);
@@ -141,71 +138,46 @@ export class Session {
static async start(browser: Browser, url: string, repoRoot: string, opts: SessionOptions): Promise<Session> {
const s = new Session(opts);
try {
await withDeadline(s.initialize(browser, url, repoRoot, opts), 5 * 60_000, "session startup");
return s;
} catch (error) {
try {
await s.close();
} catch (cleanup) {
throw new AggregateError([error, cleanup], "Session startup and cleanup failed", { cause: cleanup });
}
throw error;
}
}
copyProject(repoRoot, opts.fixture, s.root);
if (!opts.keepHome) rmSync(s.home, { recursive: true, force: true, maxRetries: 5, retryDelay: 500 });
mkdirSync(s.home, { recursive: true });
private async initialize(browser: Browser, url: string, repoRoot: string, opts: SessionOptions) {
copyProject(repoRoot, opts.fixture, this.root);
if (!opts.keepHome) rmSync(this.home, { recursive: true, force: true, maxRetries: 5, retryDelay: 500 });
mkdirSync(this.home, { recursive: true });
this.server = await Server.start(this.home, opts.log ? { OPENIDEA_LOG: opts.log } : {});
if (this.closed) {
await this.server.close();
throw new Error("session already closed");
}
this.server.onEvent = (target, event) => {
s.server = await Server.start(s.home, opts.log ? { OPENIDEA_LOG: opts.log } : {});
s.server.onEvent = (target, event) => {
if (target !== null && target !== "main") return;
this.timeline.onEvent(event as { type: string });
this.notify("event", target, event);
s.timeline.onEvent(event as { type: string });
s.notify("event", target, event);
};
this.server.onChannel = (id, data) => this.notify("channel", id, data);
await this.server.invoke("project_trust_set", { path: this.root, trusted: true, folder: false });
s.server.onChannel = (id, data) => s.notify("channel", id, data);
await s.server.invoke("project_trust_set", { path: s.root, trusted: true, folder: false });
this.context = await browser.newContext({
s.context = await browser.newContext({
baseURL: url,
viewport: { width: 1400, height: 900 },
deviceScaleFactor: 1,
});
if (this.closed) {
await withDeadline(this.context.close(), 5000, "late session context close");
throw new Error("session already closed");
}
await this.context.exposeFunction("__openideaEvalRenameAnswer", (scope: number) =>
this.renameObservations.wait(scope),
);
await this.context.exposeFunction("__openideaRelay", async (cmd: string, args: unknown) => {
const start = this.timeline.now();
this.timeline.inFlight++;
const answered = this.timeline.sent(cmd, start);
await s.context.exposeFunction("__openideaRelay", async (cmd: string, args: unknown) => {
const start = s.timeline.now();
s.timeline.inFlight++;
const answered = s.timeline.sent(cmd, start);
try {
const value = await this.renameObservations.invoke(cmd, args, () => this.server.invoke(cmd, args));
this.record(cmd, start, true, value);
const value = await s.server.invoke(cmd, args);
s.record(cmd, start, true, value);
return { ok: value ?? null };
} catch (err) {
this.record(cmd, start, false, err);
s.record(cmd, start, false, err);
return { err };
} finally {
answered();
this.timeline.inFlight--;
this.timeline.lastActivity = this.timeline.now();
s.timeline.inFlight--;
s.timeline.lastActivity = s.timeline.now();
}
});
await this.context.addInitScript(installTauriShim, {
await s.context.addInitScript(installTauriShim, {
directories: { 12: tmpdir(), 21: homedir() },
sep: sep as "/" | "\\",
});
await this.context.addInitScript(() => {
await s.context.addInitScript(() => {
const w = window as unknown as ShimWindow & {
__openideaRelay(cmd: string, args: unknown): Promise<{ ok: unknown } | { err: unknown }>;
};
@@ -215,24 +187,25 @@ export class Session {
return r.ok;
};
});
await this.context.addInitScript(installInPage);
this.page = await this.context.newPage();
this.page.on("pageerror", (e) => this.pageErrors.push(e.message));
await s.context.addInitScript(installInPage);
s.page = await s.context.newPage();
s.page.on("pageerror", (e) => s.pageErrors.push(e.message));
if (process.env.OPENIDEA_EVAL_DEBUG) {
this.page.on("console", (m) => console.log("[page]", m.type(), m.text().slice(0, 300)));
this.page.on("pageerror", (e) => console.log("[pageerror]", e.message));
s.page.on("console", (m) => console.log("[page]", m.type(), m.text().slice(0, 300)));
s.page.on("pageerror", (e) => console.log("[pageerror]", e.message));
}
await this.page.goto("/");
await this.page.waitForFunction(() => "__openideaPerf" in window && "__openideaShim" in window);
await this.page.evaluate(
await s.page.goto("/");
await s.page.waitForFunction(() => "__openideaPerf" in window && "__openideaShim" in window);
await s.page.evaluate(
(root) =>
(window as unknown as { __openideaPerf: { openProject(p: string): Promise<void> } }).__openideaPerf.openProject(
root,
),
this.root,
s.root,
);
await this.page.waitForSelector('[role="tree"][aria-label="Project"] [role="treeitem"]', { timeout: 60_000 });
await s.page.waitForSelector('[role="tree"][aria-label="Project"] [role="treeitem"]', { timeout: 60_000 });
return s;
}
private record(cmd: string, start: number, ok: boolean, value: unknown) {
@@ -248,6 +221,7 @@ export class Session {
? (value as { locations: unknown[] }).locations.length
: undefined;
this.timeline.calls.push({ cmd, start, ms: this.timeline.now() - start, ok, bytes, items });
if (ok) this.lastAnswer.set(cmd, value);
}
/** Delivers server notifications in order, batched per turn of the event loop. */
@@ -289,7 +263,20 @@ export class Session {
/** Opens `rel` (project-relative, or a URI) in an editor and waits until its text is shown. */
async openFile(rel: string) {
const path = /^[a-z]+:\/\//.test(rel) ? rel : join(this.root, rel);
await this.page.evaluate(openFileMeasured, { path, timeoutMs: 30_000 });
const bare = rel.replace(/[?#].*$/, "");
const name = bare.slice(bare.lastIndexOf("/") + 1);
await this.page.evaluate(
async ({ path, name }) => {
const w = window as unknown as {
__perf: { waitShown(s: string, t: string | null, ms: number): Promise<number> };
__openideaPerf: { openFile(p: string): Promise<void> };
};
await w.__openideaPerf.openFile(path);
await w.__perf.waitShown('[role="tab"][aria-selected="true"]', name, 30_000);
await w.__perf.waitShown(".cm-content .cm-line", null, 30_000);
},
{ path, name },
);
}
/**
@@ -412,7 +399,6 @@ export class Session {
/** Back to an idle workbench: popups dismissed, edits undone, every editor closed. */
async reset() {
this.renameObservations.reset();
// Show Usages invoked again within 4 s of its hint widens the previous search: wait it out.
const since = await this.page.evaluate(() => {
const at = (window as unknown as { __openideaEvalShowUsagesAt?: number }).__openideaEvalShowUsagesAt;
@@ -433,13 +419,7 @@ export class Session {
}
async close() {
this.closed = true;
this.renameObservations.reset();
const results = await Promise.allSettled([
this.context ? withDeadline(this.context.close(), 5000, "session context close") : Promise.resolve(),
this.server?.close(),
]);
const errors = results.flatMap((r) => (r.status === "rejected" ? [r.reason] : []));
if (errors.length) throw new AggregateError(errors, "Session cleanup failed");
await this.context?.close().catch(() => {});
await this.server?.close();
}
}
+4 -46
Переглянути файл
@@ -20,11 +20,10 @@ const outcome = (o: Partial<Outcome>): Outcome => ({
});
const repro = () => "pnpm eval --only usages";
const expected = [{ scenario: "usages", title: "Show Usages", condition: "warm" as const }];
describe("judge", () => {
test("within budgets and matching the golden passes", () => {
const [v] = judge([outcome({})], budgets, null, repro, expected);
const [v] = judge([outcome({})], budgets, null, repro);
expect(v).toMatchObject({ id: "usages@warm", status: "pass", failures: [], repro: "pnpm eval --only usages" });
});
@@ -40,7 +39,6 @@ describe("judge", () => {
budgets,
null,
repro,
expected,
);
expect(v!.status).toBe("fail");
expect(v!.failures.map((f) => [f.kind, f.metric])).toEqual([
@@ -54,29 +52,21 @@ describe("judge", () => {
test("condition budgets override scenario budgets", () => {
const [v] = judge(
[
outcome({
condition: "cold",
metrics: { feedbackMs: 40, firstResultMs: 300, completeMs: 5000, recall: 1, precision: 1 },
}),
],
[outcome({ condition: "cold", metrics: { feedbackMs: 40, completeMs: 5000, recall: 1, precision: 1 } })],
budgets,
null,
repro,
[{ ...expected[0]!, condition: "cold" }],
);
expect(v!.status).toBe("pass");
});
test("timeouts and missing goldens fail", () => {
const [timedOut] = judge(
[outcome({ error: "find.showUsages timed out after 30000 ms" })],
const [timedOut, noGolden] = judge(
[outcome({ error: "find.showUsages timed out after 30000 ms" }), outcome({ comparison: undefined })],
budgets,
null,
repro,
expected,
);
const [noGolden] = judge([outcome({ comparison: undefined })], budgets, null, repro, expected);
expect(timedOut!.failures[0]!.kind).toBe("timeout");
expect(noGolden!.failures[0]!.kind).toBe("golden");
});
@@ -88,41 +78,9 @@ describe("judge", () => {
budgets,
baseline,
repro,
expected,
);
expect(v!.status).toBe("pass");
expect(v!.regressions.map((r) => r.metric)).toEqual(["completeMs"]);
expect(table([v!], false)).toContain("regressed: completeMs");
});
test("missing, duplicate, unexpected and empty workloads fail", () => {
for (const actual of [[], [outcome({}), outcome({})], [outcome({ scenario: "other" })]]) {
expect(judge(actual, budgets, null, repro, expected).some((v) => v.status === "fail")).toBe(true);
}
expect(judge([], budgets, null, repro, []).some((v) => v.status === "fail")).toBe(true);
});
test.each(["feedbackMs", "firstResultMs", "completeMs", "recall", "precision"])("requires finite %s", (metric) => {
for (const value of [undefined, NaN, Infinity, -Infinity]) {
const o = outcome({});
if (value === undefined) delete o.metrics[metric];
else o.metrics[metric] = value;
const [v] = judge([o], budgets, null, repro, expected);
expect(v!.status).toBe("fail");
expect(v!.failures.some((f) => f.metric === metric)).toBe(true);
}
});
test("requires scenario budget metrics and rejects nonfinite unbudgeted values", () => {
const custom = { ...budgets, scenarios: { usages: { readyMs: 100 } } };
expect(judge([outcome({})], custom, null, repro, expected)[0]!.status).toBe("fail");
const o = outcome({});
o.metrics.extraMs = NaN;
expect(judge([o], budgets, null, repro, expected)[0]!.status).toBe("fail");
});
test("a clean empty result set with a perfect comparison passes", () => {
const o = outcome({ results: { problems: [] } });
expect(judge([o], budgets, null, repro, expected)[0]!.status).toBe("pass");
});
});
+2 -30
Переглянути файл
@@ -4,7 +4,6 @@
*/
import { readFileSync } from "node:fs";
import type { Comparison, ResultSet } from "./golden.ts";
import type { ExpectedOutcome } from "./selection.ts";
export type Condition = "warm" | "cold";
@@ -98,42 +97,15 @@ export function judge(
budgets: Budgets,
baseline: Outcome[] | null,
repro: (o: Outcome) => string,
expected: readonly ExpectedOutcome[],
): Verdict[] {
const base = new Map((baseline ?? []).map((o) => [idOf(o), o.metrics]));
const expectedIds = new Set(expected.map(idOf));
const counts = new Map<string, number>();
for (const o of outcomes) counts.set(idOf(o), (counts.get(idOf(o)) ?? 0) + 1);
const work: Outcome[] = [...outcomes];
for (const e of expected) {
if (!counts.has(idOf(e))) work.push({ ...e, metrics: {}, samples: {}, error: "missing expected outcome" });
}
if (!work.length) work.push({ scenario: "workload", title: "Workload", condition: "warm", metrics: {}, samples: {} });
return work.map((o) => {
return outcomes.map((o) => {
const failures: Failure[] = [];
if (!expected.length) failures.push({ kind: "error", detail: "expected workload is empty" });
if (expectedIds.size !== expected.length) failures.push({ kind: "error", detail: "duplicate expected outcome" });
if (!expectedIds.has(idOf(o))) failures.push({ kind: "error", detail: "unexpected outcome" });
if ((counts.get(idOf(o)) ?? 0) > 1) failures.push({ kind: "error", detail: "duplicate outcome" });
if (o.error) failures.push({ kind: /timed out/.test(o.error) ? "timeout" : "error", detail: o.error });
if (o.degraded) failures.push({ kind: "degraded", detail: o.degraded });
if (o.results && !o.comparison && !o.error)
failures.push({ kind: "golden", detail: "no golden recorded: run with --update-golden and review it" });
const limits = budgetsFor(budgets, o);
const required = new Set(["feedbackMs", "firstResultMs", "completeMs", ...Object.keys(limits)]);
if (o.results || o.comparison) {
required.add("recall");
required.add("precision");
}
for (const metric of new Set([...required, ...Object.keys(o.metrics)])) {
if (!Number.isFinite(o.metrics[metric]))
failures.push({
kind: lowerBound(metric) ? "correctness" : "budget",
metric,
detail: `${metric} is missing or nonfinite`,
});
}
for (const [metric, limit] of Object.entries(limits)) {
for (const [metric, limit] of Object.entries(budgetsFor(budgets, o))) {
const value = o.metrics[metric];
if (value === undefined || !Number.isFinite(value)) continue;
const over = lowerBound(metric) ? value < limit : value > limit;
+84 -193
Переглянути файл
@@ -13,29 +13,18 @@
* and target/eval/report.md. Timings go over the remote-development route (one stdio hop
* more than Tauri IPC): compare them before / after on one machine, not as absolute numbers.
*/
import { execFileSync } from "node:child_process";
import { execFileSync, spawnSync } from "node:child_process";
import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
import type { Server as HttpServer } from "node:http";
import { join, resolve } from "node:path";
import { parseArgs } from "node:util";
import type { Browser } from "@playwright/test";
import { chromium, type Browser } from "@playwright/test";
import { buildBundle, serveBundle } from "../perf/lib/bundle.ts";
import { runCommand } from "../perf/lib/process.ts";
import { closeServer, DeadlineError, launchBrowser, withDeadline, type BrowserSession } from "../perf/lib/lifecycle.ts";
import {
errorMessage,
evidenceJson,
metricErrors,
summarizeMetrics,
summarizeTrials,
type Trial,
} from "../perf/lib/trials.ts";
import { median } from "../perf/lib/stats.ts";
import { JAVA_SCENARIOS } from "./java/scenarios.ts";
import { compare, readGolden, toolDrift, writeGolden, type ResultSet } from "./lib/golden.ts";
import { TimeoutError } from "./lib/measure.ts";
import { fingerprint, pinnedTools, sameMachine, toolVersions, type Fingerprint } from "./lib/machine.ts";
import type { EvalScenario } from "./lib/scenario.ts";
import { planSelection } from "./lib/selection.ts";
import { Session } from "./lib/session.ts";
import { idOf, judge, loadBudgets, table, type Condition, type Diagnostics, type Outcome } from "./lib/verdict.ts";
@@ -67,22 +56,25 @@ if (args.list) {
process.exit(0);
}
const { runs, warmup, selected, expected, condition: conditionFilter } = planSelection(SCENARIOS, args);
const trialEvidence: Record<string, Array<Trial & { results?: ResultSet; degraded?: string | null }>> = {};
const evalBudgets = loadBudgets(join(ROOT, "evals", "budgets.json"));
const runs = Math.max(1, Number(args.runs));
const warmup = Math.max(0, Number(args.warmup));
const only = args.only?.split(",").map((s) => s.trim());
const conditionFilter = args.condition as Condition | undefined;
const selected = SCENARIOS.filter((s) => !only || only.some((o) => s.id === o || s.id.startsWith(`${o}.`)));
if (only && !selected.length) throw new Error(`no scenario matches ${args.only} (see --list)`);
const goldenFile = (id: string) => join(ROOT, "evals", id.slice(0, id.indexOf(".")), "golden", `${id}.json`);
async function serverBinary(): Promise<string> {
function serverBinary(): string {
const exe = process.platform === "win32" ? ".exe" : "";
const bin = process.env.OPENIDEA_SERVER ?? join(ROOT, "target", "release", `openidea-server${exe}`);
if (!args["no-build"]) {
console.log("Building openidea-server (cargo build --release)…");
await runCommand("cargo", ["build", "--release", "-p", "ide-host", "--bin", "openidea-server"], {
const r = spawnSync("cargo", ["build", "--release", "-p", "ide-host", "--bin", "openidea-server"], {
cwd: ROOT,
timeoutMs: 60 * 60_000,
label: "cargo build",
stdio: ["ignore", "ignore", "inherit"],
});
if (r.status !== 0) throw new Error("cargo build failed");
}
if (!existsSync(bin)) throw new Error(`no server at ${bin}; run without --no-build`);
return bin;
@@ -90,12 +82,23 @@ async function serverBinary(): Promise<string> {
function git(...a: string[]): string {
try {
return execFileSync("git", a, { cwd: ROOT, encoding: "utf8", timeout: 10_000, killSignal: "SIGKILL" }).trim();
return execFileSync("git", a, { cwd: ROOT, encoding: "utf8" }).trim();
} catch {
return "";
}
}
/** Medians of the timings; correctness from the worst run. */
function summarize(samples: Array<Record<string, number>>): Record<string, number> {
const keys = [...new Set(samples.flatMap((s) => Object.keys(s)))];
return Object.fromEntries(
keys.map((k) => {
const values = samples.map((s) => s[k]!).filter(Number.isFinite);
return [k, k === "recall" || k === "precision" ? Math.min(...values) : median(values)];
}),
);
}
interface Run {
metrics: Record<string, number>;
results?: ResultSet;
@@ -154,10 +157,8 @@ function outcomeOf(
scenario: scenario.id,
title: scenario.title,
condition,
metrics: { ...summarizeMetrics(samples, ["recall", "precision"]), ...extra },
samples: Object.fromEntries(
[...new Set(samples.flatMap((s) => Object.keys(s)))].map((k) => [k, samples.map((x) => x[k]!)]),
),
metrics: { ...summarize(samples), ...extra },
samples: Object.fromEntries(Object.keys(samples[0] ?? {}).map((k) => [k, samples.map((x) => x[k]!)])),
results: done.at(-1)?.results,
comparison: worst,
drift: golden ? toolDrift(golden, tools) : undefined,
@@ -171,59 +172,21 @@ async function runScenario(
condition: Condition,
browser: Browser,
tools: Record<string, string>,
progress: () => void,
extra: Record<string, number> = {},
): Promise<Outcome> {
const total = condition === "cold" ? 1 : warmup + runs;
const done: Run[] = [];
process.stdout.write(`${idOf({ scenario: scenario.id, condition }).padEnd(52)} `);
const attempts: Array<Trial & { results?: ResultSet; degraded?: string | null }> = (trialEvidence[
idOf({ scenario: scenario.id, condition })
] = []);
let phase: Trial["phase"] = condition === "warm" && warmup ? "warmup" : "measured";
let index = 1;
try {
for (let i = 0; i < total; i++) {
const last = i === total - 1;
const trace = args.trace && last ? join(OUT, "traces", `${scenario.id}@${condition}.json`) : null;
phase = condition === "warm" && i < warmup ? "warmup" : "measured";
index = phase === "warmup" ? i + 1 : condition === "cold" ? 1 : i - warmup + 1;
const r = await withDeadline(measureOnce(s, scenario, trace, browser), 5 * 60_000, `${scenario.id} trial`);
const golden = readGolden(goldenFile(scenario.id));
const comparison = golden && r.results ? compare(r.results, golden.groups) : undefined;
const metrics = comparison
? { ...r.metrics, recall: comparison.recall, precision: comparison.precision }
: r.metrics;
const limits = {
...evalBudgets.defaults,
...evalBudgets.scenarios[scenario.id],
...evalBudgets.scenarios[idOf({ scenario: scenario.id, condition })],
};
const required = [
"feedbackMs",
"firstResultMs",
"completeMs",
...Object.keys(limits).filter((k) => k !== "recall" && k !== "precision"),
];
const errors = metricErrors(metrics, required);
if (r.degraded) errors.push(r.degraded);
if (comparison && (comparison.recall < 1 || comparison.precision < 1)) errors.push("result differs from golden");
attempts.push({
phase,
index,
status: errors.length ? "invalid" : "ok",
metrics,
results: r.results,
degraded: r.degraded,
error: errors.join("; ") || undefined,
});
if (phase === "measured") done.push(r);
progress();
process.stdout.write(errors.length ? "!" : phase === "warmup" ? "w" : ".");
const r = await measureOnce(s, scenario, trace, browser);
if (condition === "cold" || i >= warmup) done.push(r);
process.stdout.write(condition === "warm" && i < warmup ? "w" : ".");
}
console.log();
const o = outcomeOf(scenario, condition, done, tools, extra);
o.error = summarizeTrials(attempts, condition === "cold" ? 1 : runs).error;
const slowest = done.reduce((a, b) => ((b.metrics.completeMs ?? 0) > (a.metrics.completeMs ?? 0) ? b : a));
o.diagnostics = diagnose(
s,
@@ -236,15 +199,6 @@ async function runScenario(
const message = e instanceof Error ? e.message : String(e);
const partial = e instanceof TimeoutError ? (e.partial as Record<string, number>) : {};
const now = s.timeline.now();
if (!attempts.some((t) => t.phase === phase && t.index === index))
attempts.push({
phase,
index,
status: e instanceof DeadlineError || e instanceof TimeoutError ? "timeout" : "error",
metrics: partial,
error: message,
});
progress();
return {
...outcomeOf(scenario, condition, done, tools, extra),
metrics: { ...partial, ...extra },
@@ -256,113 +210,69 @@ async function runScenario(
async function main() {
mkdirSync(join(OUT, "traces"), { recursive: true });
const outcomes: Outcome[] = [];
const infrastructure: string[] = [];
process.env.OPENIDEA_SERVER = serverBinary();
if (!args["no-build"]) buildBundle(ROOT, DIST);
if (!existsSync(join(DIST, "index.html"))) throw new Error(`no build in ${DIST}; run without --no-build`);
const tools = toolVersions();
const pins = pinnedTools(join(ROOT, ".github", "tool-versions.env"));
const machine: Fingerprint = fingerprint();
const date = new Date().toISOString();
let tools: Record<string, string> = {};
let pins: Record<string, string> = {};
let runtime: BrowserSession | undefined;
let server: HttpServer | undefined;
let browserVersion = "not started";
const progress = () => {
writeFileSync(
join(OUT, "report.json"),
evidenceJson({
meta: { date, runs, warmup, machine, tools, pins },
status: "running",
pass: false,
expected,
outcomes,
trials: trialEvidence,
}),
);
};
progress();
writeFileSync(join(OUT, "report.md"), "# OpenIDEA eval report\n\nRun in progress; no passing verdict.\n");
for (const [k, want] of Object.entries(pins)) {
if (tools[k] !== undefined && !tools[k]!.startsWith(want))
console.warn(`warning: ${k} ${tools[k]} is not the pinned ${want} (.github/tool-versions.env)`);
}
const { server, url } = await serveBundle(DIST);
const browser = await chromium.launch({
channel: args.channel === "chromium" ? undefined : args.channel,
headless: !args.headed,
args: [
"--disable-renderer-backgrounding",
"--disable-background-timer-throttling",
"--disable-backgrounding-occluded-windows",
],
});
const outcomes: Outcome[] = [];
try {
process.env.OPENIDEA_SERVER = await serverBinary();
if (!args["no-build"]) await buildBundle(ROOT, DIST);
if (!existsSync(join(DIST, "index.html"))) throw new Error(`no build in ${DIST}; run without --no-build`);
tools = toolVersions();
pins = pinnedTools(join(ROOT, ".github", "tool-versions.env"));
for (const [k, want] of Object.entries(pins)) {
if (tools[k] !== undefined && !tools[k]!.startsWith(want))
console.warn(`warning: ${k} ${tools[k]} is not the pinned ${want} (.github/tool-versions.env)`);
}
const serving = await serveBundle(DIST);
server = serving.server;
runtime = await launchBrowser({
channel: args.channel === "chromium" ? undefined : args.channel,
headless: !args.headed,
args: [
"--disable-renderer-backgrounding",
"--disable-background-timer-throttling",
"--disable-backgrounding-occluded-windows",
],
});
const browser = runtime.browser;
browserVersion = browser.version();
// Warm: one session per fixture, its project imported once, scenarios one after another.
const warm = selected.filter(
(s) => s.conditions.includes("warm") && (!conditionFilter || conditionFilter === "warm"),
);
for (const fixture of [...new Set(warm.map((s) => s.fixture))]) {
const scenarios = warm.filter((s) => s.fixture === fixture);
const s = await Session.start(browser, serving.url, ROOT, {
fixture,
workDir: join(OUT, "warm"),
keepHome: false,
});
const s = await Session.start(browser, url, ROOT, { fixture, workDir: join(OUT, "warm"), keepHome: false });
try {
await withDeadline(scenarios[0]!.setup(s), 5 * 60_000, "warm fixture setup");
await scenarios[0]!.setup(s);
await s.settle(scenarios[0]!.server);
for (const scenario of scenarios) {
const outcome = await runScenario(s, scenario, "warm", browser, tools, progress);
outcomes.push(outcome);
progress();
if (outcome.error) break;
}
for (const scenario of scenarios) outcomes.push(await runScenario(s, scenario, "warm", browser, tools));
} finally {
await s.close();
}
}
// Cold: a fresh server and project import per scenario, measured once after the import settles.
const cold = selected.filter(
(s) => s.conditions.includes("cold") && (!conditionFilter || conditionFilter === "cold"),
);
for (const scenario of cold) {
const started = Date.now();
const s = await Session.start(browser, serving.url, ROOT, {
const s = await Session.start(browser, url, ROOT, {
fixture: scenario.fixture,
workDir: join(OUT, "cold"),
keepHome: false,
});
try {
await withDeadline(scenario.setup(s), 5 * 60_000, "cold fixture setup");
await scenario.setup(s);
await s.settle(scenario.server);
// Settling waits out the quiet period at its end.
const readyMs = Date.now() - started - 2000;
outcomes.push(await runScenario(s, scenario, "cold", browser, tools, progress, { readyMs }));
progress();
outcomes.push(await runScenario(s, scenario, "cold", browser, tools, { readyMs }));
} finally {
await s.close();
}
}
} catch (error) {
infrastructure.push(errorMessage(error));
} finally {
if (runtime) {
try {
await runtime.close();
} catch (error) {
infrastructure.push(`browser cleanup: ${errorMessage(error)}`);
}
}
if (server) {
try {
await closeServer(server);
} catch (error) {
infrastructure.push(`server cleanup: ${errorMessage(error)}`);
}
}
await browser.close();
server.close();
}
if (args["update-golden"]) {
@@ -381,19 +291,15 @@ async function main() {
const baselineFile = join(OUT, "baseline.json");
let baseline: Outcome[] | null = null;
if (existsSync(baselineFile)) {
try {
const saved = JSON.parse(readFileSync(baselineFile, "utf8")) as { machine: Fingerprint; outcomes: Outcome[] };
if (sameMachine(saved.machine, machine)) baseline = saved.outcomes;
else console.warn("warning: target/eval/baseline.json is from another machine or OS: not compared");
} catch (error) {
infrastructure.push(`baseline: ${errorMessage(error)}`);
}
const saved = JSON.parse(readFileSync(baselineFile, "utf8")) as { machine: Fingerprint; outcomes: Outcome[] };
if (sameMachine(saved.machine, machine)) baseline = saved.outcomes;
else console.warn("warning: target/eval/baseline.json is from another machine or OS: not compared");
}
const repro = (o: Outcome) => `pnpm eval --only ${o.scenario} --condition ${o.condition}`;
const verdicts = judge(outcomes, evalBudgets, baseline, repro, expected);
const verdicts = judge(outcomes, loadBudgets(join(ROOT, "evals", "budgets.json")), baseline, repro);
const meta = {
date,
date: new Date().toISOString(),
commit: git("rev-parse", "--short", "HEAD"),
dirty: git("status", "--porcelain", "--untracked-files=no") !== "",
runs,
@@ -401,32 +307,27 @@ async function main() {
machine,
tools,
pins,
browser: browserVersion,
browser: browser.version(),
};
const report = {
meta,
pass: infrastructure.length === 0 && verdicts.every((v) => v.status === "pass"),
status: infrastructure.length || verdicts.some((v) => v.status === "fail") ? "failed" : "complete",
expected,
outcomes,
trials: trialEvidence,
infrastructure,
pass: verdicts.every((v) => v.status === "pass"),
verdicts: verdicts.map((v) => {
const o = outcomes.find((x) => idOf(x) === v.id);
const o = outcomes.find((x) => idOf(x) === v.id)!;
return {
...v,
samples: o?.samples,
results: o?.results,
comparison: o?.comparison,
drift: o?.drift,
degraded: o?.degraded,
error: o?.error,
samples: o.samples,
results: o.results,
comparison: o.comparison,
drift: o.drift,
degraded: o.degraded,
error: o.error,
// Diagnostics only where something needs a look.
diagnostics: v.status === "fail" || v.regressions.length ? o?.diagnostics : undefined,
diagnostics: v.status === "fail" || v.regressions.length ? o.diagnostics : undefined,
};
}),
};
writeFileSync(join(OUT, "report.json"), evidenceJson(report));
writeFileSync(join(OUT, "report.json"), JSON.stringify(report, null, 2));
const failing = verdicts.filter((v) => v.status === "fail");
const md = [
"# OpenIDEA eval report",
@@ -436,16 +337,6 @@ async function main() {
table(verdicts, true),
"",
...failing.flatMap((v) => [`- **${v.id}**: ${v.failures.map((f) => f.detail).join("; ")} — \`${v.repro}\``]),
...infrastructure.map((error) => `- **Infrastructure**: ${error}`),
"",
"## Trials",
"",
"| Scenario | Valid / planned measured | Attempted measured | Valid / attempted warmup |",
"| --- | ---: | ---: | ---: |",
...Object.entries(trialEvidence).map(([id, attempts]) => {
const c = summarizeTrials(attempts, id.endsWith("@cold") ? 1 : runs).counts;
return `| ${id} | ${c.valid}/${c.planned} | ${c.attempted} | ${c.warmupValid}/${c.warmupAttempted} |`;
}),
].join("\n");
writeFileSync(join(OUT, "report.md"), md + "\n");
@@ -454,9 +345,9 @@ async function main() {
for (const v of failing) {
console.log(`\n${v.id} FAILED (${v.repro})`);
for (const f of v.failures) console.log(` ${f.kind}: ${f.detail}`);
const o = outcomes.find((x) => idOf(x) === v.id);
if (o?.drift?.length) console.log(` golden recorded with other tools: ${o.drift.join(", ")}`);
const slow = [...(o?.diagnostics?.calls ?? [])].sort((a, b) => b.ms - a.ms).slice(0, 5);
const o = outcomes.find((x) => idOf(x) === v.id)!;
if (o.drift?.length) console.log(` golden recorded with other tools: ${o.drift.join(", ")}`);
const slow = [...(o.diagnostics?.calls ?? [])].sort((a, b) => b.ms - a.ms).slice(0, 5);
if (slow.length)
console.log(
` slowest commands: ${slow.map((c) => `${c.cmd} ${Math.round(c.ms)} ms${c.pending ? " (no answer)" : c.ok ? "" : " (failed)"}`).join(", ")}`,
@@ -464,11 +355,11 @@ async function main() {
}
console.log(`\nReport: ${join(OUT, "report.json")}`);
if (args["save-baseline"]) {
writeFileSync(baselineFile, evidenceJson({ machine, meta, outcomes }));
writeFileSync(baselineFile, JSON.stringify({ machine, meta, outcomes }, null, 2));
console.log(`Baseline saved to ${baselineFile}`);
}
const regressed = verdicts.some((v) => v.regressions.length);
process.exit(infrastructure.length || failing.length || (args["fail-on-regression"] && regressed) ? 1 : 0);
process.exit(failing.length || (args["fail-on-regression"] && regressed) ? 1 : 0);
}
await main();
+1 -1
Переглянути файл
@@ -3,7 +3,7 @@ import type { KnipConfig } from "knip";
const config: KnipConfig = {
// Entries come from the Vite (index.html), Vitest, Playwright and package.json script plugins;
// standalone browser fixtures are loaded by their own HTML pages.
entry: ["e2e/*.fixture.{ts,tsx}", "perf/**/*.fixture.{ts,tsx}"],
entry: ["e2e/*.fixture.{ts,tsx}"],
project: [
"src/**/*.{ts,tsx,css}",
"!src/editor/core/cm/angular/parser.terms.ts",
+4 -42
Переглянути файл
@@ -23,46 +23,9 @@ closes it, and records:
| `exit_s` | until every process has exited |
| `cache_mb`, install size | `cache_dirs`, `install_dir` |
Apps run interleaved, rotating the order, after `--warmup` unaggregated runs.
Every attempt, including warmups and failed launches, is retained in
`results/<time>-<project>-<unique>/`: `report.md`, `results.json`, and each
launched run's stdout. Reports are refreshed before and after each attempt
and on errors or interruption; separate invocations never overwrite each other.
The table shows median (min–max) and **valid/attempted** measured-trial counts
for every fixed metric, even when there are zero valid values. Only completely
valid trials enter aggregates; failed trials retain partial measurements and
explicit reasons in JSON and the attempts table. Warmups never enter medians
but a failed warmup still fails the suite. An empty or incomplete suite is not
successful.
Startup timeout, early exit/crash, observation/access errors, invalid or missing
required metrics, quit-command errors, forced termination, and interruption
produce a nonzero exit. JSON records `status`, `reasons`, `warmup`, and
`metric_status` (`valid`, `missing`, `invalid`, or `unsupported`). Nonfinite
numeric evidence is preserved as an `invalid_number` object, never JSON NaN.
Unsupported window observation, non-Linux PSS, and unconfigured cache directories
are explicit exclusions rather than missing required values. Unobserved optional
log markers do not fail a trial; `ready_after` markers are required.
`--runs` must be positive; `--warmup` and `--cooldown` may be zero. Other
durations and the CPU threshold must be finite and positive, and the quiet
period cannot exceed the startup timeout.
Shutdown always runs after a launch, including observation errors and Ctrl-C.
`--close-timeout` bounds the quit command plus graceful wait; each forced cleanup
has at most two additional seconds to reap processes. `--command-timeout`
(default 60 seconds) bounds `--drop-os-cache`, including interactive commands.
Only processes attributed to the launch are terminated; preexisting instances
are refused, never killed. Configured `daemons` remain explicitly excluded from
shutdown and forced cleanup. POSIX launch-owned process groups retain orphaned
children; on Windows discovery uses the recorded process ancestry.
Run the small process-fixture regressions without launching an installed IDE:
```sh
python -m unittest discover -s perf/compare -p 'test_bench.py'
```
Apps run interleaved, rotating the order, after `--warmup` discarded runs.
Output goes to `results/<time>-<project>/`: `report.md` (median, min–max),
`results.json`, and each run's stdout.
## Fair runs
@@ -83,7 +46,6 @@ python -m unittest discover -s perf/compare -p 'test_bench.py'
- Windows: windows via `user32`, closed with `WM_CLOSE`.
- macOS: windows via Quartz (`pyobjc-framework-Quartz`; titles need Screen
Recording permission). WebKit helpers are children of launchd and are
attributed through `responsibility_get_pid_responsible_for_pid`. Without that
API, unrelated WebKit processes are not guessed by name/start time or killed.
attributed through `responsibility_get_pid_responsible_for_pid`.
- Linux: windows via `wmctrl` (X11). Without it `window_s` is skipped and
readiness counts from launch.
+180 -391
Переглянути файл
@@ -14,7 +14,6 @@ import ctypes
import datetime as dt
import glob
import json
import math
import os
import platform
import re
@@ -25,7 +24,6 @@ import subprocess
import sys
import time
import tomllib
import tempfile
from pathlib import Path
try:
@@ -36,7 +34,7 @@ except ImportError:
OS = {"Windows": "windows", "Darwin": "macos", "Linux": "linux"}[platform.system()]
HERE = Path(__file__).resolve().parent
ANSI = re.compile(r"\x1b\[[0-9;?]*[A-Za-z]")
GONE = (psutil.NoSuchProcess, psutil.ZombieProcess)
GONE = (psutil.NoSuchProcess, psutil.ZombieProcess, psutil.AccessDenied)
MB = 1024 * 1024
POLL_S = 0.2
@@ -142,7 +140,10 @@ def _mac_windows(pids: set[int]) -> list[tuple[object, str]] | None:
def _x11_windows(pids: set[int]) -> list[tuple[object, str]] | None:
if not shutil.which("wmctrl"):
return None
out = subprocess.run(["wmctrl", "-lp"], capture_output=True, text=True, timeout=2, check=True).stdout
try:
out = subprocess.run(["wmctrl", "-lp"], capture_output=True, text=True, timeout=2).stdout
except (OSError, subprocess.TimeoutExpired):
return None
found = []
for line in out.splitlines():
parts = line.split(None, 4)
@@ -173,11 +174,11 @@ if OS == "macos":
class Tree:
"""Processes owned by this launch, identified by process identity and ancestry.
"""Every process the app started, including ones whose parent already exited.
POSIX launches have a private process group, retaining orphaned children.
macOS launchd-owned WebKit helpers require responsible-pid attribution:
name/start-time guesses cannot safely authorize terminating a process.
On macOS, WKWebView's helper processes are children of launchd, so they are
attributed through the responsible-pid API (or, failing that, by name and
start time).
"""
def __init__(self, root: psutil.Process, started: float):
@@ -186,22 +187,14 @@ class Tree:
self.procs: dict[tuple[int, float], psutil.Process] = {}
self.cpu: dict[tuple[int, float], float] = {}
self.cpu_exited = 0.0
self.group = root.pid if os.name == "posix" else None
def _discover(self):
found = [self.root]
for p in [self.root, *self.procs.values()]:
for p in list(self.procs.values()):
try:
found += p.children(recursive=True)
except GONE:
pass
if self.group is not None:
for p in psutil.process_iter():
try:
if os.getpgid(p.pid) == self.group:
found.append(p)
except (ProcessLookupError, PermissionError):
continue
if OS == "macos":
found += self._webkit()
for p in found:
@@ -218,7 +211,8 @@ class Tree:
if _responsible:
if _responsible(p.pid) == self.root.pid:
out.append(p)
# Without attribution, leave unrelated WebKit processes untouched.
elif (p.info["create_time"] or 0) >= self.started - 1:
out.append(p)
return out
def sample(self) -> tuple[float, int]:
@@ -240,14 +234,7 @@ class Tree:
return {pid for pid, _ in self.procs}
def alive(self) -> list[psutil.Process]:
out = []
for p in self.procs.values():
try:
if p.is_running() and p.status() != psutil.STATUS_ZOMBIE:
out.append(p)
except GONE:
pass
return out
return [p for p in self.procs.values() if p.is_running()]
def memory(self) -> dict:
"""Summed memory of the live tree. RSS double-counts shared pages, USS leaves them out."""
@@ -297,7 +284,7 @@ class LogTail:
f.seek(self.offsets.get(path, 0))
chunk = f.read()
self.offsets[path] = f.tell()
except FileNotFoundError:
except OSError:
continue
if not chunk:
continue
@@ -323,246 +310,151 @@ def dir_size(path: Path) -> int:
if path.is_file():
return path.stat().st_size
total = 0
def walk_error(error):
raise error
for root, _, files in os.walk(path, onerror=walk_error):
for root, _, files in os.walk(path):
for f in files:
try:
total += os.lstat(os.path.join(root, f)).st_size
except FileNotFoundError:
except OSError:
pass
return total
def failure(result: dict, reason: str):
result["reasons"].append(reason)
if result["status"] != "interrupted":
result["status"] = "failed"
def close(app: App, tree: Tree, proc: subprocess.Popen, timeout: float) -> tuple[float | None, list[str]]:
"""Asks the app to quit, waits for the whole tree, kills what's left.
Returns (seconds until every process exited, or None if it had to kill; names of killed leftovers).
"""
t0 = time.perf_counter()
if app.quit_command:
subprocess.run(app.quit_command, check=False)
elif OS == "windows":
# Only the project windows: closing a framework's hidden message windows
# (Tauri's single-instance and event-target ones) stalls the real shutdown.
for hwnd, title in _win_windows(tree.pids()):
if app.window_title.search(title):
_user32.PostMessageW(hwnd, 0x0010, 0, 0) # WM_CLOSE
else:
proc.send_signal(signal.SIGTERM)
def force_cleanup(tree: Tree | None, proc: subprocess.Popen, daemons: set[str], result: dict) -> list[str]:
"""Kill only launch-owned identities; allow at most two seconds to reap."""
def remaining() -> list[psutil.Process]:
out = []
for p in tree.alive():
try:
if p.name().lower() not in app.daemons:
out.append(p)
except GONE:
pass
return out
while time.perf_counter() - t0 < timeout:
tree.sample()
if not remaining():
return time.perf_counter() - t0, []
time.sleep(POLL_S)
leftovers = remaining()
names = []
targets = []
if tree is not None:
for p in leftovers:
try:
tree._discover()
except Exception as exc:
failure(result, f"cleanup discovery: {type(exc).__name__}: {exc}")
targets = list(tree.procs.values())
try:
# A reaped PID may already belong to somebody else.
if proc.poll() is None:
root = psutil.Process(proc.pid)
if all(p.pid != root.pid for p in targets):
targets.append(root)
except GONE:
pass
killed = []
for p in targets:
try:
if not p.is_running() or p.status() == psutil.STATUS_ZOMBIE:
continue
name = p.name()
if name.lower() in daemons:
result.setdefault("excluded_daemons", []).append({"pid": p.pid, "name": name})
continue
names.append(p.name())
p.kill()
names.append(name)
killed.append(p)
except GONE:
pass
except Exception as exc:
failure(result, f"cleanup pid {p.pid}: {type(exc).__name__}: {exc}")
deadline = time.perf_counter() + 2
if killed:
_, alive = psutil.wait_procs(killed, timeout=max(0, deadline - time.perf_counter()))
if alive:
failure(result, f"cleanup survivors: {[p.pid for p in alive]}")
try:
proc.wait(timeout=max(0, deadline - time.perf_counter()))
except subprocess.TimeoutExpired:
# The root can itself be an explicitly excluded daemon.
if not any(p["pid"] == proc.pid for p in result.get("excluded_daemons", [])):
failure(result, f"cleanup root {proc.pid} did not exit")
return names
psutil.wait_procs(leftovers, timeout=10)
return None, names
def bounded_command(command, timeout: float, *, shell=False):
"""External cache/quit commands have their own launch-owned cleanup."""
proc = subprocess.Popen(command, shell=shell, stdin=subprocess.DEVNULL,
start_new_session=os.name == "posix")
tree = None
evidence = {"status": "valid", "reasons": []}
try:
tree = Tree(psutil.Process(proc.pid), time.time())
deadline = time.perf_counter() + timeout
while proc.poll() is None:
tree._discover()
remaining = deadline - time.perf_counter()
if remaining <= 0:
raise subprocess.TimeoutExpired(command, timeout)
time.sleep(min(POLL_S, remaining))
if proc.returncode:
raise subprocess.CalledProcessError(proc.returncode, command)
finally:
force_cleanup(tree, proc, set(), evidence)
if evidence["reasons"]:
raise RuntimeError("; ".join(evidence["reasons"]))
def run_once(app: App, args, out_dir: Path, label: str) -> dict:
running = running_instances(app) if app.single_instance else []
if running:
pids = ", ".join(str(p.pid) for p in running)
raise SystemExit(f"{app.name} is already running (pid {pids}); close it first, it would take over the launch.")
if args.wipe_caches:
for path in app.cache_paths():
shutil.rmtree(path, ignore_errors=True) if path.is_dir() else path.unlink(missing_ok=True)
if args.drop_os_cache:
subprocess.run(args.drop_os_cache, shell=True, check=True)
if args.cooldown:
time.sleep(args.cooldown)
stdout_path = out_dir / f"{label}.stdout.log"
tail = LogTail(app.logs, [stdout_path])
started_wall = time.time()
with open(stdout_path, "wb") as stdout:
t0 = time.perf_counter()
proc = subprocess.Popen(app.command, stdout=stdout, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL)
tree = Tree(psutil.Process(proc.pid), started_wall)
def close(app: App, tree: Tree, proc: subprocess.Popen, timeout: float, result: dict) -> tuple[float | None, list[str]]:
"""The quit command and graceful wait share one budget; forced reap is bounded."""
t0 = time.perf_counter()
deadline = t0 + timeout
exit_s = None
killed = []
try:
tree._discover()
if app.quit_command:
try:
bounded_command(app.quit_command, max(0.001, deadline - time.perf_counter()))
except Exception as exc:
failure(result, f"quit command: {type(exc).__name__}: {exc}")
elif OS == "windows":
for hwnd, title in _win_windows(tree.pids()):
if app.window_title.search(title):
_user32.PostMessageW(hwnd, 0x0010, 0, 0)
elif proc.poll() is None:
proc.send_signal(signal.SIGTERM)
result: dict = {"app": app.key, "label": label, "markers_first_s": {}, "markers_last_s": {}}
window_supported = True
window_s = None
history: collections.deque[tuple[float, float]] = collections.deque()
peak_rss = 0
ready_s = None
while time.perf_counter() < deadline:
tree._discover()
remaining = [p for p in tree.alive() if p.name().lower() not in app.daemons]
if not remaining:
exit_s = time.perf_counter() - t0
while True:
now = time.perf_counter() - t0
cpu, rss = tree.sample()
peak_rss = max(peak_rss, rss)
history.append((now, cpu))
while history and now - history[0][0] > args.quiet_secs:
history.popleft()
for line in tail.lines():
for name, rx in app.markers.items():
if rx.search(line):
result["markers_first_s"].setdefault(name, now)
result["markers_last_s"][name] = now
if window_s is None and window_supported:
windows = visible_windows(tree.pids())
if windows is None:
window_supported = False
elif any(app.window_title.search(title) for _, title in windows):
window_s = now
if not tree.alive():
raise SystemExit(
f"{app.name} exited during startup (code {proc.poll()}); an instance started elsewhere may have "
f"taken the launch. Output: {stdout_path}"
)
waited = (window_s is not None or not window_supported) and all(
m in result["markers_first_s"] for m in app.ready_after
)
span = now - history[0][0]
if waited and span >= args.quiet_secs * 0.95:
busy = (cpu - history[0][1]) / span
if busy < args.quiet_cores:
# Never before what it waited for (the quiet span can start earlier).
ready_s = max(now - span, window_s or 0, *(result["markers_first_s"][m] for m in app.ready_after))
break
time.sleep(min(POLL_S, max(0, deadline - time.perf_counter())))
if exit_s is None:
failure(result, "graceful-close timeout")
except KeyboardInterrupt:
result["status"] = "interrupted"
failure(result, "interrupted during shutdown")
except Exception as exc:
failure(result, f"shutdown observation: {type(exc).__name__}: {exc}")
finally:
killed = force_cleanup(tree, proc, app.daemons, result)
if killed:
failure(result, "forced cleanup: " + ", ".join(killed))
exit_s = None
return exit_s, killed
if now > args.timeout:
result["timed_out"] = True
break
time.sleep(POLL_S)
result["window_s"] = window_s
result["ready_s"] = ready_s
result["peak_rss_mb"] = peak_rss / MB
def new_trial(app: App, label: str, warmup=False) -> dict:
return {"app": app.key, "label": label, "warmup": warmup, "status": "running", "reasons": [],
"markers_first_s": {}, "markers_last_s": {}, "metric_status": {},
**{key: None for key, _ in METRICS}}
# Idle: what it costs to just sit there with the project open.
idle_cpu0, _ = tree.sample()
i0 = time.perf_counter()
while time.perf_counter() - i0 < args.idle_secs:
time.sleep(POLL_S * 5)
_, rss = tree.sample()
peak_rss = max(peak_rss, rss)
idle_cpu1, _ = tree.sample()
result["idle_cpu_pct"] = 100 * (idle_cpu1 - idle_cpu0) / (time.perf_counter() - i0)
result["peak_rss_mb"] = peak_rss / MB
result.update(tree.memory())
result["total_cpu_s"] = idle_cpu0
def run_once(app: App, args, out_dir: Path, label: str, result: dict | None = None) -> dict:
result = new_trial(app, label) if result is None else result
proc = tree = None
try:
running = running_instances(app) if app.single_instance else []
if running:
raise RuntimeError(f"{app.name} already running (pid {', '.join(str(p.pid) for p in running)}); close it first")
if args.wipe_caches:
for path in app.cache_paths():
shutil.rmtree(path) if path.is_dir() else path.unlink(missing_ok=True)
if args.drop_os_cache:
bounded_command(args.drop_os_cache, args.command_timeout, shell=True)
if args.cooldown:
time.sleep(args.cooldown)
stdout_path = out_dir / f"{label}.stdout.log"
result["stdout"] = str(stdout_path)
tail = LogTail(app.logs, [stdout_path])
started_wall = time.time()
with open(stdout_path, "wb") as stdout:
t0 = time.perf_counter()
proc = subprocess.Popen(app.command, stdout=stdout, stderr=subprocess.STDOUT,
stdin=subprocess.DEVNULL, start_new_session=os.name == "posix")
result["pid"] = proc.pid
tree = Tree(psutil.Process(proc.pid), started_wall)
window_supported = True
history: collections.deque[tuple[float, float]] = collections.deque()
peak_rss = 0
while True:
now = time.perf_counter() - t0
cpu, rss = tree.sample()
peak_rss = max(peak_rss, rss)
result["peak_rss_mb"] = peak_rss / MB
history.append((now, cpu))
while history and now - history[0][0] > args.quiet_secs:
history.popleft()
for line in tail.lines():
for name, rx in app.markers.items():
if rx.search(line):
result["markers_first_s"].setdefault(name, now)
result["markers_last_s"][name] = now
if result["window_s"] is None and window_supported:
windows = visible_windows(tree.pids())
if windows is None:
window_supported = False
result["metric_status"]["window_s"] = "unsupported"
elif any(app.window_title.search(title) for _, title in windows):
result["window_s"] = now
if proc.poll() is not None or not tree.alive():
raise RuntimeError(f"{app.name} exited during startup (code {proc.poll()})")
waited = (result["window_s"] is not None or not window_supported) and all(
m in result["markers_first_s"] for m in app.ready_after)
span = now - history[0][0]
if waited and span >= args.quiet_secs * 0.95:
busy = (cpu - history[0][1]) / span
if busy < args.quiet_cores:
result["ready_s"] = max(now - span, result["window_s"] or 0,
*(result["markers_first_s"][m] for m in app.ready_after))
break
if now > args.timeout:
result["timed_out"] = True
raise TimeoutError("startup timeout: CPU/window/required markers never became ready")
time.sleep(POLL_S)
idle_cpu0, _ = tree.sample()
result["total_cpu_s"] = idle_cpu0
i0 = time.perf_counter()
while time.perf_counter() - i0 < args.idle_secs:
time.sleep(min(POLL_S * 5, max(0, args.idle_secs - (time.perf_counter() - i0))))
_, rss = tree.sample()
peak_rss = max(peak_rss, rss)
result["peak_rss_mb"] = peak_rss / MB
if proc.poll() is not None or not tree.alive():
raise RuntimeError(f"{app.name} exited during idle (code {proc.poll()})")
idle_cpu1, _ = tree.sample()
result["idle_cpu_pct"] = 100 * (idle_cpu1 - idle_cpu0) / (time.perf_counter() - i0)
result.update(tree.memory())
result["cache_mb"] = sum(dir_size(p) for p in app.cache_paths()) / MB
result["status"] = "valid"
except KeyboardInterrupt:
result["status"] = "interrupted"
failure(result, "interrupted")
except Exception as exc:
failure(result, f"{type(exc).__name__}: {exc}")
finally:
if proc is not None:
try:
if tree is not None:
result["exit_s"], result["killed_on_exit"] = close(app, tree, proc, args.close_timeout, result)
else:
result["killed_on_exit"] = force_cleanup(tree, proc, app.daemons, result)
except KeyboardInterrupt:
result["status"] = "interrupted"
failure(result, "interrupted during cleanup")
result["killed_on_exit"] = force_cleanup(tree, proc, app.daemons, result)
except Exception as exc:
failure(result, f"cleanup: {type(exc).__name__}: {exc}")
result["killed_on_exit"] = force_cleanup(tree, proc, app.daemons, result)
result["exit_code"] = proc.poll()
validate_metrics(app, result)
exit_s, killed = close(app, tree, proc, args.close_timeout)
result["exit_s"] = exit_s
if killed:
result["killed_on_exit"] = killed
result["cache_mb"] = sum(dir_size(p) for p in app.cache_paths()) / MB
return result
@@ -583,67 +475,8 @@ METRICS = [
]
def valid_number(value) -> bool:
return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value) and value >= 0
def validate_metrics(app: App, result: dict):
states = result["metric_status"]
for key, _ in METRICS:
if (key == "pss_mb" and OS != "linux") or (key == "cache_mb" and not app.cache_dirs):
states[key] = "unsupported"
continue
if key == "window_s" and states.get(key) == "unsupported":
continue
value = result.get(key)
good = valid_number(value) and (key != "procs" or (value > 0 and value == int(value)))
states[key] = "valid" if good else "missing" if value is None else "invalid"
if not good:
reason = f"required metric {key}: {states[key]}"
if reason not in result["reasons"]:
failure(result, reason)
for marker in app.ready_after:
if not valid_number(result["markers_first_s"].get(marker)):
reason = f"required marker {marker}: missing or invalid"
if reason not in result["reasons"]:
failure(result, reason)
def json_safe(value):
"""Strict JSON retains invalid numeric evidence without emitting NaN/Infinity."""
if isinstance(value, float) and not math.isfinite(value):
return {"invalid_number": str(value)}
if isinstance(value, dict):
return {key: json_safe(v) for key, v in value.items()}
if isinstance(value, list):
return [json_safe(v) for v in value]
return value
def suite_status(apps: list[App], runs: list[dict], meta: dict) -> str:
if meta.get("suite_errors") or not runs or any(r["status"] != "valid" for r in runs):
return "failed"
for app in apps:
measured = [r for r in runs if r["app"] == app.key and not r["warmup"]]
if len(measured) != meta["runs"]:
return "failed"
return "valid"
def persist(apps: list[App], runs: list[dict], meta: dict, out_dir: Path):
meta["status"] = suite_status(apps, runs, meta)
# JSON first: report rendering must never discard the raw failure evidence.
def replace(name, text):
temporary = out_dir / (name + ".tmp")
temporary.write_text(text, encoding="utf-8")
temporary.replace(out_dir / name)
replace("results.json", json.dumps(json_safe({"meta": meta, "runs": runs}), indent=2, allow_nan=False))
replace("report.md", report(apps, runs, meta))
def fmt(value: float | None) -> str:
return "–" if not valid_number(value) else f"{value:.2f}"
return "–" if value is None else f"{value:.2f}"
def summarize(values: list[float]) -> str:
@@ -656,25 +489,15 @@ def summarize(values: list[float]) -> str:
def report(apps: list[App], runs: list[dict], meta: dict) -> str:
measured = [r for r in runs if not r.get("warmup", False)]
def column(app: App, getter) -> str:
vals = [v for r in runs if r["app"] == app.key and (v := getter(r)) is not None]
return summarize(vals)
def column(app: App, key, getter, owner=None) -> str:
attempts = [r for r in measured if r["app"] == app.key]
vals = [v for r in attempts if r["status"] == "valid"
and (owner is None or owner == app.key)
and r.get("metric_status", {}).get(key) != "unsupported"
and valid_number(v := getter(r))]
unsupported = sum(r.get("metric_status", {}).get(key) == "unsupported" for r in attempts)
suffix = " unsupported" if unsupported or (owner is not None and owner != app.key) else ""
return f"{summarize(vals)} [{len(vals)}/{len(attempts)}]{suffix}"
rows = [(key, title, lambda r, k=key: r.get(k), None) for key, title in METRICS]
rows = [(title, lambda r, k=key: r.get(k)) for key, title in METRICS]
for app in apps:
for m in app.markers:
rows.append((None, f"{app.name}: log `{m}` first (s)",
lambda r, m=m: r["markers_first_s"].get(m), app.key))
rows.append((None, f"{app.name}: log `{m}` last (s)",
lambda r, m=m: r["markers_last_s"].get(m), app.key))
rows.append((f"{app.name}: log `{m}` first (s)", lambda r, m=m: r["markers_first_s"].get(m)))
rows.append((f"{app.name}: log `{m}` last (s)", lambda r, m=m: r["markers_last_s"].get(m)))
lines = [
f"# IDE benchmark: {meta['project']}",
@@ -682,34 +505,24 @@ def report(apps: list[App], runs: list[dict], meta: dict) -> str:
f"{meta['os']} · {meta['cpu']} · {meta['cores']} cores · {meta['ram_gb']:.0f} GB RAM · "
f"mode **{meta['mode']}** · {meta['runs']} runs · {meta['date']}",
"",
f"Status: **{meta.get('status', 'failed')}**. Median (min–max), [valid/attempted] measured trials.",
"Only valid trials enter aggregates; warmups and partial evidence remain below and in JSON.",
"Times are seconds from launch. Unsupported metrics are not required; missing required metrics fail a trial.",
"Median (min–max). Times are seconds from launch.",
"",
"| Metric | " + " | ".join(a.name for a in apps) + " |",
"|---|" + "---|" * len(apps),
]
for key, title, getter, owner in rows:
cells = [column(a, key, getter, owner) for a in apps]
lines.append(f"| {title} | " + " | ".join(cells) + " |")
lines += ["", "## Attempts (including warmups)", "", "| Trial | Status | Reasons |",
"|---|---|---|"]
for r in runs:
label = r["label"] + (" (warmup)" if r.get("warmup") else "")
reasons = "; ".join(r["reasons"]).replace("|", "\\|").replace("\n", " ")
lines.append(f"| {label} | {r['status']} | {reasons or '–'} |")
for error in meta.get("suite_errors", []):
lines.append(f"\nSuite error: {error}")
if not runs:
lines.append("\nNo trials completed: suite is not successful.")
for title, getter in rows:
cells = [column(a, getter) for a in apps]
if any(c != "–" for c in cells):
lines.append(f"| {title} | " + " | ".join(cells) + " |")
for app in apps:
if app.install_dir:
try:
path = Path(app.install_dir)
if path.exists():
lines.append(f"\n{app.name} install size: {dir_size(path) / MB:.0f} MB")
except OSError as exc:
lines.append(f"\n{app.name} install size unavailable: {exc}")
if app.install_dir and Path(app.install_dir).exists():
lines.append(f"\n{app.name} install size: {dir_size(Path(app.install_dir)) / MB:.0f} MB")
timeouts = [r["label"] for r in runs if r.get("timed_out")]
if timeouts:
lines.append(f"\n⚠ CPU never settled within the timeout: {', '.join(timeouts)}")
killed = [f"{r['label']}: {', '.join(r['killed_on_exit'])}" for r in runs if r.get("killed_on_exit")]
if killed:
lines.append("\n⚠ Killed after the exit timeout: " + "; ".join(killed))
return "\n".join(lines) + "\n"
@@ -722,7 +535,7 @@ def main():
ap.add_argument("--config", type=Path, default=HERE / "apps.toml")
ap.add_argument("--apps", help="comma-separated keys from the config (default: all)")
ap.add_argument("--runs", type=int, default=5, help="measured runs per app (default 5)")
ap.add_argument("--warmup", type=int, default=1, help="unaggregated warmup runs per app first (default 1)")
ap.add_argument("--warmup", type=int, default=1, help="discarded runs per app first (default 1)")
ap.add_argument("--wipe-caches", action="store_true", help="delete each app's cache_dirs before every run (cold index)")
ap.add_argument("--drop-os-cache", metavar="CMD", help="shell command run before every run to drop the OS file cache")
ap.add_argument("--quiet-secs", type=float, default=5, help="CPU must stay low this long to count as ready")
@@ -730,19 +543,10 @@ def main():
ap.add_argument("--idle-secs", type=float, default=30, help="idle period measured after ready")
ap.add_argument("--timeout", type=float, default=900, help="give up waiting for ready after this many seconds")
ap.add_argument("--close-timeout", type=float, default=60)
ap.add_argument("--command-timeout", type=float, default=60, help="OS cache command deadline in seconds")
ap.add_argument("--cooldown", type=float, default=5, help="pause before each launch")
ap.add_argument("--out", type=Path, default=HERE / "results")
ap.add_argument("--yes", action="store_true", help="don't ask before wiping caches")
args = ap.parse_args()
if args.runs <= 0 or args.warmup < 0:
ap.error("--runs must be positive and --warmup must be nonnegative")
for name in ("quiet_secs", "quiet_cores", "idle_secs", "timeout", "close_timeout", "command_timeout", "cooldown"):
value = getattr(args, name)
if not math.isfinite(value) or value < 0 or (name != "cooldown" and value == 0):
ap.error(f"--{name.replace('_', '-')} must be finite and {'nonnegative' if name == 'cooldown' else 'positive'}")
if args.quiet_secs > args.timeout:
ap.error("--quiet-secs must not exceed --timeout")
if hasattr(sys.stdout, "reconfigure"):
sys.stdout.reconfigure(encoding="utf-8")
@@ -751,8 +555,6 @@ def main():
raise SystemExit(f"not a directory: {project}")
config = tomllib.loads(args.config.read_text(encoding="utf-8"))
keys = args.apps.split(",") if args.apps else list(config["apps"])
if not keys or any(not key or key not in config["apps"] for key in keys) or len(set(keys)) != len(keys):
ap.error("--apps must select at least one known app without duplicates")
apps = [App(k, config["apps"][k], project) for k in keys]
if args.wipe_caches:
@@ -765,8 +567,8 @@ def main():
return
stamp = dt.datetime.now().strftime("%Y%m%d-%H%M%S")
args.out.mkdir(parents=True, exist_ok=True)
out_dir = Path(tempfile.mkdtemp(prefix=f"{stamp}-{project.name}-", dir=args.out))
out_dir = args.out / f"{stamp}-{project.name}"
out_dir.mkdir(parents=True)
mode = "cold index" if args.wipe_caches else "warm"
if args.drop_os_cache:
mode += " + cold OS cache"
@@ -784,42 +586,29 @@ def main():
}
runs: list[dict] = []
previous_term = signal.signal(signal.SIGTERM, lambda *_: (_ for _ in ()).throw(KeyboardInterrupt()))
try:
persist(apps, runs, meta, out_dir)
total = args.warmup + args.runs
for i in range(total):
# Rotate the order so neither app always runs right after the other.
order = apps[i % len(apps) :] + apps[: i % len(apps)]
for app in order:
warm = i < args.warmup
label = f"{app.key}-{'warmup' if warm else 'run'}{i + 1 if warm else i - args.warmup + 1}"
r = new_trial(app, label, warm)
total = args.warmup + args.runs
for i in range(total):
# Rotate the order so neither app always runs right after the other.
order = apps[i % len(apps) :] + apps[: i % len(apps)]
for app in order:
warm = i < args.warmup
label = f"{app.key}-{'warmup' if warm else 'run'}{i + 1 if warm else i - args.warmup + 1}"
print(f"[{label}] launching…", flush=True)
r = run_once(app, args, out_dir, label)
print(
f"[{label}] window {fmt(r['window_s'])} s · ready {fmt(r['ready_s'])} s · "
f"USS {r['uss_mb']:.0f} MB · idle CPU {r['idle_cpu_pct']:.1f}%",
flush=True,
)
if not warm:
runs.append(r)
persist(apps, runs, meta, out_dir)
print(f"[{label}] launching…", flush=True)
run_once(app, args, out_dir, label, r)
persist(apps, runs, meta, out_dir)
print(f"[{label}] {r['status']} · window {fmt(r['window_s'])} s · ready {fmt(r['ready_s'])} s", flush=True)
if r["status"] == "interrupted":
raise KeyboardInterrupt
except KeyboardInterrupt:
meta.setdefault("suite_errors", []).append("interrupted")
for r in runs:
if r["status"] == "running":
r["status"] = "interrupted"
failure(r, "interrupted before launch completed")
except Exception as exc:
meta.setdefault("suite_errors", []).append(f"{type(exc).__name__}: {exc}")
for r in runs:
if r["status"] == "running":
failure(r, "suite aborted before launch completed")
finally:
signal.signal(signal.SIGTERM, previous_term)
persist(apps, runs, meta, out_dir)
(out_dir / "results.json").write_text(json.dumps({"meta": meta, "runs": runs}, indent=2), encoding="utf-8")
text = report(apps, runs, meta)
(out_dir / "report.md").write_text(text, encoding="utf-8")
print("\n" + text)
print(f"Raw results: {out_dir / 'results.json'}")
return 0 if meta["status"] == "valid" else 1
if __name__ == "__main__":
sys.exit(main())
main()
-211
Переглянути файл
@@ -1,211 +0,0 @@
"""Small real-process regressions; no installed IDE or window server required."""
import argparse
import importlib.util
import json
import math
import os
from pathlib import Path
import signal
import subprocess
import sys
import tempfile
import time
import unittest
from unittest.mock import patch
import psutil
spec = importlib.util.spec_from_file_location("compare_bench", Path(__file__).with_name("bench.py"))
bench = importlib.util.module_from_spec(spec)
spec.loader.exec_module(bench)
class TrialTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.out = Path(self.temp.name)
self.args = argparse.Namespace(wipe_caches=False, drop_os_cache=None, cooldown=0,
quiet_secs=0.03, quiet_cores=100, timeout=0.3, idle_secs=0.03, close_timeout=0.3,
command_timeout=0.3)
self.windows = patch.object(bench, "visible_windows", return_value=None)
self.windows.start()
self.addCleanup(self.windows.stop)
poll = patch.object(bench, "POLL_S", 0.01)
poll.start()
self.addCleanup(poll.stop)
def app(self, source, **extra):
return bench.App("fixture", {"command": sys.executable, "args": ["-c", source],
"single_instance": False, **extra}, self.out)
def assert_failed(self, result, reason):
self.assertNotEqual(result["status"], "valid")
self.assertTrue(any(reason in r for r in result["reasons"]), result)
def test_crash_preserves_attempt(self):
result = bench.run_once(self.app("import sys; print('before crash', flush=True); sys.exit(7)"),
self.args, self.out, "crash")
self.assert_failed(result, "exited")
self.assertEqual(result["exit_code"], 7)
self.assertIn("before crash", (self.out / "crash.stdout.log").read_text())
def test_startup_timeout(self):
app = self.app("import time; time.sleep(30)", markers={"ready": "NEVER"}, ready_after=["ready"])
result = bench.run_once(app, self.args, self.out, "timeout")
self.assert_failed(result, "startup timeout")
self.assertIsNone(result["ready_s"])
self.assertEqual(result["metric_status"]["window_s"], "unsupported")
def test_blocked_quit_is_bounded(self):
app = self.app("import time; time.sleep(30)",
quit_command=[sys.executable, "-c", "import time; time.sleep(30)"])
start = time.monotonic()
result = bench.run_once(app, self.args, self.out, "blocked")
self.assertLess(time.monotonic() - start, 4)
self.assert_failed(result, "quit command")
self.assertTrue(result["killed_on_exit"])
def test_observation_failure_and_interruption_clean_children(self):
for error in (RuntimeError("observer failed"), psutil.AccessDenied(os.getpid()), KeyboardInterrupt()):
with self.subTest(error=type(error).__name__):
pidfile = self.out / "child.pid"
pidfile.unlink(missing_ok=True)
source = ("import subprocess,sys,time; "
"p=subprocess.Popen([sys.executable,'-c','import time; time.sleep(30)']); "
f"open({str(pidfile)!r},'w').write(str(p.pid)); time.sleep(30)")
original = bench.Tree.sample
triggered = False
def observe(tree):
nonlocal triggered
sampled = original(tree)
if pidfile.exists() and not triggered:
triggered = True
raise error
return sampled
with patch.object(bench.Tree, "sample", observe):
result = bench.run_once(self.app(source), self.args, self.out, "observe")
self.assertTrue(triggered)
self.assertNotEqual(result["status"], "valid")
child = psutil.Process(int(pidfile.read_text())) if psutil.pid_exists(int(pidfile.read_text())) else None
if child:
self.assertEqual(child.status(), psutil.STATUS_ZOMBIE)
def test_existing_instance_is_not_terminated(self):
proc = subprocess.Popen([sys.executable, "-c", "import time; time.sleep(30)"])
try:
with patch.object(bench, "running_instances", return_value=[psutil.Process(proc.pid)]):
app = self.app("raise AssertionError('must not launch')")
app.single_instance = True
result = bench.run_once(app, self.args, self.out, "preexisting")
self.assert_failed(result, "already running")
self.assertIsNone(proc.poll())
finally:
proc.kill()
proc.wait(timeout=2)
def test_report_keeps_empty_rows_and_denominators(self):
app = self.app("pass")
runs = []
for index, value in enumerate((1.0, None, math.inf)):
result = bench.new_trial(app, str(index))
result.update(status="valid", ready_s=value)
bench.validate_metrics(app, result)
runs.append(result)
runs[0].update({key: 1.0 for key, _ in bench.METRICS})
runs[0]["procs"] = 1
runs[0]["status"] = "valid"
runs[0]["reasons"] = []
bench.validate_metrics(app, runs[0])
text = bench.report([app], runs, {"project": "fixture", "os": "test", "cpu": "test", "cores": 1,
"ram_gb": 1, "mode": "warm", "runs": 3, "date": "today", "status": "failed"})
self.assertIn("1/3", text)
self.assertIn("failed", text)
self.assertIn("PSS after idle", text)
self.assertIn("0/3", text)
self.assertNotIn("inf", text)
encoded = json.dumps(bench.json_safe(runs), allow_nan=False)
self.assertIn("invalid_number", encoded)
self.assertEqual(bench.suite_status([app], [], {"runs": 1}), "failed")
def test_cache_command_timeout_cleans_its_child(self):
pidfile = self.out / "cache-child.pid"
source = ("import subprocess,sys,time; "
"p=subprocess.Popen([sys.executable,'-c','import time; time.sleep(30)']); "
f"open({str(pidfile)!r},'w').write(str(p.pid)); time.sleep(30)")
with self.assertRaises(subprocess.TimeoutExpired):
bench.bounded_command([sys.executable, "-c", source], 0.3)
self.assertTrue(pidfile.exists())
pid = int(pidfile.read_text())
if psutil.pid_exists(pid):
self.assertEqual(psutil.Process(pid).status(), psutil.STATUS_ZOMBIE)
@unittest.skipUnless(os.name == "posix", "CLI SIGINT delivery requires POSIX")
def test_cli_interruption_preserves_reports_and_cleans_child(self):
pidfile = self.out / "cli-child.pid"
source = ("import subprocess,sys,time; "
"p=subprocess.Popen([sys.executable,'-c','import time; time.sleep(30)']); "
f"open({str(pidfile)!r},'w').write(str(p.pid)); time.sleep(30)")
config = self.out / "interrupt.toml"
config.write_text("[apps.fixture]\ncommand = " + json.dumps(sys.executable)
+ "\nargs = " + json.dumps(["-c", source]) + "\nsingle_instance = false\n")
proc = subprocess.Popen([sys.executable, str(Path(bench.__file__)), str(self.out),
"--config", str(config), "--runs", "1", "--warmup", "0", "--cooldown", "0",
"--close-timeout", "0.3", "--out", str(self.out / "results")],
stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
try:
deadline = time.monotonic() + 5
while not pidfile.exists() and proc.poll() is None and time.monotonic() < deadline:
time.sleep(0.01)
self.assertTrue(pidfile.exists(), "fixture did not launch")
proc.send_signal(signal.SIGINT)
proc.communicate(timeout=5)
self.assertNotEqual(proc.returncode, 0)
output = next((self.out / "results").iterdir())
raw = json.loads((output / "results.json").read_text())
self.assertEqual(raw["runs"][0]["status"], "interrupted")
self.assertEqual(raw["meta"]["status"], "failed")
self.assertIn("interrupted", (output / "report.md").read_text())
pid = int(pidfile.read_text())
if psutil.pid_exists(pid):
self.assertEqual(psutil.Process(pid).status(), psutil.STATUS_ZOMBIE)
finally:
if proc.poll() is None:
proc.kill()
proc.communicate(timeout=3)
# A regression must not leak the fixture even when an assertion fails.
if pidfile.exists():
pid = int(pidfile.read_text())
try:
psutil.Process(pid).kill()
except psutil.NoSuchProcess:
pass
def test_cli_failed_launch_writes_both_reports_and_nonzero(self):
config = self.out / "apps.toml"
config.write_text('[apps.fixture]\ncommand = "/missing/benchmark-fixture"\nargs = []\nsingle_instance = false\n')
result = subprocess.run([sys.executable, str(Path(bench.__file__)), str(self.out),
"--config", str(config), "--runs", "1", "--warmup", "1", "--cooldown", "0",
"--out", str(self.out / "results")], capture_output=True, text=True, timeout=5)
self.assertNotEqual(result.returncode, 0)
output = next((self.out / "results").iterdir())
raw = json.loads((output / "results.json").read_text())
self.assertEqual(len(raw["runs"]), 2)
self.assertTrue(raw["runs"][0]["warmup"])
self.assertEqual(raw["meta"]["status"], "failed")
self.assertIn("failed", (output / "report.md").read_text())
def test_invalid_numeric_arguments_do_not_launch(self):
for flag, value in (("--runs", "0"), ("--warmup", "-1"), ("--idle-secs", "nan"),
("--close-timeout", "inf"), ("--quiet-cores", "0")):
result = subprocess.run([sys.executable, str(Path(bench.__file__)), str(self.out), flag, value,
"--out", str(self.out / "results")],
capture_output=True, text=True, timeout=5)
self.assertNotEqual(result.returncode, 0)
self.assertFalse((self.out / "results").exists())
if __name__ == "__main__":
unittest.main()
+13 -9
Переглянути файл
@@ -1,16 +1,21 @@
/** The workbench's `--mode perf` production bundle: building it and serving it to Chromium. */
import { runCommand } from "./process.ts";
import { spawnSync } from "node:child_process";
import { createReadStream, existsSync, statSync } from "node:fs";
import { createServer, type Server } from "node:http";
import { extname, join } from "node:path";
export async function buildBundle(root: string, outDir: string, flags: string[] = []) {
export function buildBundle(root: string, outDir: string, flags: string[] = []) {
console.log("Building the workbench (vite build --mode perf)…");
await runCommand(
process.platform === "win32" ? "pnpm.cmd" : "pnpm",
const r = spawnSync(
"pnpm",
["exec", "vite", "build", "--mode", "perf", ...flags, "--outDir", outDir, "--emptyOutDir"],
{ cwd: root, timeoutMs: 5 * 60_000, label: "vite build" },
{
cwd: root,
stdio: ["ignore", "ignore", "inherit"],
shell: process.platform === "win32",
},
);
if (r.status !== 0) throw new Error("vite build failed");
}
const MIME: Record<string, string> = {
@@ -33,11 +38,10 @@ export function serveBundle(dir: string): Promise<{ server: Server; url: string
res.writeHead(200, { "content-type": MIME[extname(file)] ?? "application/octet-stream" });
createReadStream(file).pipe(res);
});
return new Promise((ok, reject) => {
server.once("error", reject);
return new Promise((ok) =>
server.listen(0, "127.0.0.1", () => {
const addr = server.address();
ok({ server, url: `http://127.0.0.1:${typeof addr === "object" && addr ? addr.port : 0}` });
});
});
}),
);
}
-124
Переглянути файл
@@ -1,124 +0,0 @@
import { EditorSelection, EditorState, Prec } from "@codemirror/state";
import { EditorView, keymap } from "@codemirror/view";
import { defaultKeymap, indentWithTab } from "@codemirror/commands";
import { autocompletion, closeBrackets, closeBracketsKeymap } from "@codemirror/autocomplete";
import { javascript } from "@codemirror/lang-javascript";
import { indentOnInput } from "@codemirror/language";
import type { InPage } from "./inpage.ts";
import type { EditorProbe } from "./editing.ts";
// The fixture owns both browser globals and exposes the same editor observation boundary as the app.
const w = window as unknown as {
__fixture: Record<string, boolean>;
__openideaPerf: EditorProbe;
__perf?: InPage;
__releaseOpen?: () => void;
};
const flags: Record<string, boolean> = {};
w.__fixture = flags;
const files = new Map<string, string>();
let path = "";
let view: EditorView;
const style = document.createElement("style");
style.textContent = ".cm-editor { height: 240px; width: 700px; } .cm-scroller { overflow: auto; }";
document.head.append(style);
// Registered before the measurement listener, so a lost recording is tested independently of editing.
window.addEventListener(
"keydown",
() => {
if (flags.missingSample && w.__perf) w.__perf.recordKeys = false;
},
true,
);
function mount(text: string) {
view?.destroy();
view = new EditorView({
parent: document.querySelector("#editor")!,
state: EditorState.create({
doc: text,
extensions: [
javascript(),
indentOnInput(),
closeBrackets(),
Prec.highest(
keymap.of([
{ key: "Mod-End", run: () => !!flags.disableJump },
{ key: "ArrowDown", run: () => !!flags.disableArrows },
{ key: "x", run: () => !!flags.swallowTyping },
]),
),
keymap.of([...closeBracketsKeymap, ...defaultKeymap, indentWithTab]),
autocompletion({
// Test movement itself, without CodeMirror's accidental-key guard after opening.
interactionDelay: 0,
override: [
(ctx) => {
const word = ctx.matchBefore(/\w*/);
return {
from: word?.from ?? ctx.pos,
options: Array.from({ length: 50 }, (_, i) => ({ label: `getOrder${String(i).padStart(2, "0")}` })),
};
},
],
}),
EditorView.updateListener.of((update) => {
if (flags.wrongCaret && update.docChanged)
queueMicrotask(() => view.dispatch({ selection: EditorSelection.cursor(0) }));
if (flags.mutateDistant && update.docChanged) {
flags.mutateDistant = false;
const end = view.state.doc.length;
queueMicrotask(() => view.dispatch({ changes: { from: end - 1, to: end, insert: "z" } }));
}
}),
],
}),
});
view.focus();
}
w.__openideaPerf = {
seed: (p, text) => {
files.set(p, text);
},
async openFile(p) {
if (flags.rejectOpen) throw new Error("open failed");
if (flags.ignoreOpen) return;
if (flags.delayOpen)
await new Promise<void>((resolve) => {
w.__releaseOpen = resolve;
});
path = p;
mount(flags.wrongContents ? view.state.doc.toString() : (files.get(p) ?? ""));
let tab = document.querySelector<HTMLElement>('[role="tab"]');
if (!tab) {
tab = document.createElement("div");
tab.setAttribute("role", "tab");
tab.setAttribute("aria-selected", "true");
document.body.prepend(tab);
}
tab.textContent = p.slice(p.lastIndexOf("/") + 1);
},
editorText: (from = 0, to) => view?.state.doc.sliceString(from, to) ?? null,
editorState() {
if (!view) return null;
const head = view.state.selection.main.head;
return {
path,
head,
length: view.state.doc.length,
lines: view.state.doc.lines,
line: view.state.doc.lineAt(head).number - 1,
word: "",
};
},
lineAtY(y) {
const block = view.lineBlockAtHeight(y - view.documentTop);
return view.state.doc.lineAt(block.from).number - 1;
},
setCursor(head) {
view.dispatch({ selection: EditorSelection.cursor(head), scrollIntoView: true });
view.focus();
},
};
-215
Переглянути файл
@@ -1,215 +0,0 @@
// @vitest-environment node
import { fileURLToPath } from "node:url";
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
import { chromium, type Browser, type BrowserContext, type Page } from "@playwright/test";
import { createServer, type ViteDevServer } from "vite";
import { Harness } from "./harness.ts";
import { installInPage } from "./inpage.ts";
let server: ViteDevServer;
let browser: Browser;
let context: BrowserContext;
let page: Page;
let h: Harness;
beforeAll(async () => {
server = await createServer({
configFile: false,
root: fileURLToPath(new URL("../../", import.meta.url)),
server: { host: "127.0.0.1", port: 0 },
optimizeDeps: { entries: ["perf/lib/causality.fixture.ts"] },
plugins: [
{
name: "causality-fixture",
configureServer(s) {
s.middlewares.use((req, res, next) => {
if (req.url !== "/") return next();
res.setHeader("Content-Type", "text/html");
res.end(
'<div id="editor"></div><input id="other"><div id="result">ready</div><script type="module" src="/perf/lib/causality.fixture.ts"></script>',
);
});
},
},
],
});
await server.listen();
browser = await chromium.launch({ channel: process.env.OPENIDEA_PERF_CHANNEL ?? "chromium" });
}, 30_000);
beforeEach(async () => {
context = await browser.newContext();
page = await context.newPage();
await page.goto(server.resolvedUrls!.local[0]!);
await page.waitForFunction(() => "__openideaPerf" in window);
await page.evaluate(installInPage);
const cdp = await context.newCDPSession(page);
h = new Harness(page, cdp);
});
afterEach(async () => {
await context?.close();
});
afterAll(async () => {
await browser?.close();
await server?.close();
});
async function mode(name: string) {
await page.evaluate((name) => {
const w = window as unknown as { __fixture: Record<string, boolean> };
w.__fixture[name] = true;
}, name);
}
async function fixtureFile(text = "start\nend") {
await h.openFile("/one/Same.ts", text);
await h.setCursor(0);
}
describe("current-operation UI measurements", () => {
it("observes startup without input, but rejects pre-existing DOM even after a no-op key", async () => {
expect(await h.inPage((p) => p.waitShown("#result", "ready", 500))).toBeGreaterThanOrEqual(0);
await expect(h.measure(async () => {}, "#result", "ready", 80)).rejects.toThrow("timed out");
await expect(
h.measure(
() =>
page.evaluate(() => {
document.querySelector("#result")!.textContent = "ready before input";
}),
"#result",
"ready",
80,
),
).rejects.toThrow("timed out");
await expect(
h.measure(
async () => {
await page.evaluate(() => {
document.querySelector("#result")!.textContent = "ready changed before input";
});
await page.keyboard.press("Shift");
},
"#result",
"ready",
80,
),
).rejects.toThrow("timed out");
await expect(h.measure(() => page.keyboard.press("Shift"), "#result", "ready", 80)).rejects.toThrow("timed out");
});
it("waits for input and the resulting target change, not an earlier frame", async () => {
let changedAt = 0;
const result = h.measure(
async () => {
await h.inPage((p) => p.afterNextPaint());
await page.keyboard.press("a");
await h.inPage((p) => p.afterNextPaint());
changedAt = await page.evaluate(() => {
document.querySelector("#result")!.textContent = "ready now";
return performance.now();
});
},
"#result",
"ready",
1_000,
);
const latency = await result;
expect((await h.inPage((p) => p.lastInput)) + latency).toBeGreaterThanOrEqual(changedAt);
});
it("propagates trigger failure and cancels its waiter without browser rejection", async () => {
const errors: string[] = [];
page.on("pageerror", (error) => errors.push(error.message));
await expect(
h.measure(
async () => {
throw new Error("trigger failed");
},
"#missing",
null,
80,
),
).rejects.toThrow("trigger failed");
await expect(h.measure(async () => false, "#missing", null, 80)).rejects.toThrow("returned false");
await h.inPage(async (p) => {
await p.afterNextPaint();
await p.afterNextPaint();
});
expect(errors).toEqual([]);
expect(await h.inPage((p) => p.waitShown("#result", "ready", 80))).toBeGreaterThanOrEqual(0);
});
it.each(["ignoreOpen", "wrongContents"])("requires the requested path and seeded contents with %s", async (fault) => {
await fixtureFile();
await mode(fault);
await expect(h.openFile("/two/Same.ts", "different", 100)).rejects.toThrow("requested editor");
});
it("does not finish before the open action succeeds, even with matching existing contents", async () => {
await fixtureFile();
await mode("delayOpen");
let completed = false;
const opening = h.openFile("/one/Same.ts", "start\nend").finally(() => {
completed = true;
});
await page.waitForFunction(() => "__releaseOpen" in window);
try {
await h.inPage((p) => p.afterNextPaint());
expect(completed).toBe(false);
} finally {
await page.evaluate(() => {
if (!("__releaseOpen" in window) || typeof window.__releaseOpen !== "function")
throw new Error("open action was not held");
window.__releaseOpen();
});
await opening;
}
});
it("awaits the open action and rejects failed actions even with a matching editor", async () => {
await fixtureFile();
await mode("rejectOpen");
await expect(h.openFile("/one/Same.ts")).rejects.toThrow("open failed");
});
it("measures real typing, including automatic brackets, indentation and backspace", async () => {
await fixtureFile("function f() {\n}\n");
await h.setCursor(14);
expect(await h.typeMeasured("const n = (1 + 2);\n\b", 0)).toHaveLength(20);
});
it.each(["swallowTyping", "wrongCaret", "missingSample", "wrongFocus"])("rejects typing with %s", async (fault) => {
await fixtureFile();
if (fault === "wrongFocus") await page.locator("#other").click();
else await mode(fault);
await expect(h.typeMeasured("x", 0)).rejects.toThrow(/typing|caret|sample|focus/);
});
it("checks the whole document after bounded per-key observations", async () => {
await fixtureFile("start\n" + "unchanged\n".repeat(200) + "end");
expect(await h.typeMeasured("ok", 0)).toHaveLength(2);
await mode("mutateDistant");
await expect(h.typeMeasured("x", 0)).rejects.toThrow("outside the intended insertion");
});
it("requires both cursor destination and viewport displacement for the jump", async () => {
await fixtureFile(Array.from({ length: 1_000 }, (_, i) => `export class Repository${i} {}`).join("\n"));
await mode("disableJump");
await expect(h.jumpToEnd(100)).rejects.toThrow("timed out");
await page.evaluate(() => {
const w = window as unknown as { __fixture: Record<string, boolean> };
w.__fixture.disableJump = false;
});
expect(await h.jumpToEnd(1_000)).toBeGreaterThanOrEqual(0);
expect((await h.editorState())!.head).toBe((await h.editorState())!.length);
});
it("requires each completion arrow to advance exactly one selected item", async () => {
await fixtureFile("");
await h.measure(() => page.keyboard.press("g"), ".cm-tooltip-autocomplete li", "getOrder", 2_000);
await page.waitForSelector('.cm-tooltip-autocomplete li[aria-selected="true"]');
expect(await h.completionArrowsMeasured(3, 0)).toHaveLength(3);
await mode("disableArrows");
await expect(h.completionArrowsMeasured(1, 0)).rejects.toThrow("completion selection");
});
});
-133
Переглянути файл
@@ -1,133 +0,0 @@
export interface EditorProbe {
seed(path: string, text: string): void;
openFile(path: string): Promise<void>;
editorState(): { path: string; length: number; lines: number; head: number; line: number; word: string } | null;
editorText(from?: number, to?: number): string | null;
setCursor(offset: number): void;
lineAtY(y: number): number;
}
export interface EditableSnapshot {
kind: "editor" | "input";
target: string;
text: string;
head: number;
from: number;
to: number;
}
export interface EditableRange {
from: number;
to: number;
length: number;
}
/** Runs in the page: a key latency is not evidence that the intended editable received it. */
export function readEditable(range?: EditableRange): EditableSnapshot {
const active = document.activeElement;
if (active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement) {
if (active.selectionStart === null || active.selectionEnd === null)
throw new Error("typing focus is not a text input");
return {
kind: "input",
target: active.id || active.getAttribute("aria-label") || active.tagName,
text: active.value,
head: active.selectionEnd,
from: active.selectionStart,
to: active.selectionEnd,
};
}
if (!active?.closest(".cm-content")) throw new Error("typing focus is not in the editor");
// The app and browser fixture expose this typed, in-process observation boundary.
const w = window as unknown as { __openideaPerf: EditorProbe };
const state = w.__openideaPerf.editorState();
if (!state) throw new Error("typing editor is unavailable");
const text = w.__openideaPerf.editorText(range?.from, range ? range.to + state.length - range.length : undefined);
if (text === null) throw new Error("typing editor is unavailable");
const head = state.head - (range?.from ?? 0);
return { kind: "editor", target: state.path, text, head, from: head, to: head };
}
export function assertTypedKey(before: EditableSnapshot, after: EditableSnapshot, key: string) {
const fail = () => {
throw new Error(`typing ${JSON.stringify(key)} did not produce the expected text and caret in ${before.target}`);
};
if (before.kind !== after.kind || before.target !== after.target) fail();
const left = before.text.slice(0, before.from);
const right = before.text.slice(before.to);
if (before.kind === "input") {
const from = key === "\b" && before.from === before.to ? Math.max(0, before.from - 1) : before.from;
const inserted = key === "\b" ? "" : key;
if (after.text !== before.text.slice(0, from) + inserted + right || after.head !== from + inserted.length) fail();
return;
}
const afterLeft = after.text.slice(0, after.head);
const afterRight = after.text.slice(after.head);
if (key === "\b") {
const removed = left.slice(afterLeft.length);
const pair = ({ "(": ")", "[": "]", "{": "}", '"': '"', "'": "'" } as Record<string, string>)[removed];
if (
after.head >= before.head ||
!left.startsWith(afterLeft) ||
!removed ||
([...removed].length !== 1 && !/^[\t ]+$/.test(removed)) ||
(afterRight !== right && !(pair && right.startsWith(pair) && afterRight === right.slice(pair.length)))
)
fail();
return;
}
// CodeMirror may adjust indentation, insert a matching bracket, or step over an auto-inserted closer.
// All non-indentation text, the insertion point, and the remaining document must still match.
const unindent = (text: string) => text.replace(/^[\t ]+/gm, "");
if (after.head === before.head || unindent(afterLeft) !== unindent(left + key)) fail();
const closers: Record<string, string> = { "(": ")", "[": "]", "{": "}", '"': '"', "'": "'", "`": "`" };
const closer = closers[key];
const suffix = unindent(afterRight);
const previous = unindent(right);
if (suffix === previous) return;
if (closer && suffix === closer + previous) return;
if (
/[)\]}"'`]/.test(key) &&
right.startsWith(key) &&
unindent(after.text) === unindent(before.text) &&
suffix === unindent(right.slice(key.length))
)
return;
if (key === "\n" && suffix === "\n" + previous) return;
fail();
}
/** Runs in the page; shared by UI performance scenarios and code-intelligence evals. */
export async function openFileMeasured({ path, text, timeoutMs }: { path: string; text?: string; timeoutMs: number }) {
const w = window as unknown as { __openideaPerf: EditorProbe };
const t0 = performance.now();
let timer: number | undefined;
const expired = new Promise<never>((_, reject) => {
timer = window.setTimeout(() => reject(new Error(`open action timed out for ${path}`)), timeoutMs);
});
let result: unknown;
try {
result = await Promise.race([w.__openideaPerf.openFile(path), expired]);
} finally {
window.clearTimeout(timer);
}
if (result === false) throw new Error(`open action failed for ${path}`);
while (performance.now() - t0 <= timeoutMs) {
await new Promise(requestAnimationFrame);
const state = w.__openideaPerf.editorState();
const content = w.__openideaPerf.editorText();
const editor = document.activeElement?.closest(".cm-editor");
const lines = [...(editor?.querySelectorAll<HTMLElement>(".cm-content .cm-line") ?? [])];
if (
state?.path === path &&
content !== null &&
state.length === content.length &&
(text === undefined || content === text) &&
lines.length &&
lines.some((line) => line.getClientRects().length && content.includes(line.textContent ?? ""))
) {
return performance.now() - t0;
}
}
throw new Error(`requested editor ${path} did not show its contents`);
}
+38 -164
Переглянути файл
@@ -2,7 +2,6 @@
import type { CDPSession, Page } from "@playwright/test";
import type { InPage } from "./inpage.ts";
import { median } from "./stats.ts";
import { assertTypedKey, openFileMeasured, readEditable, type EditableRange, type EditorProbe } from "./editing.ts";
export type Metrics = Record<string, number>;
@@ -70,182 +69,45 @@ export class Harness {
for (const k of await this.keysFor(actionId)) await this.page.keyboard.press(k);
}
/** Measures a current input and a changed, matching target at frame start. */
async measure<A = undefined>(
trigger: () => Promise<unknown>,
selector: string,
text: string | null = null,
timeoutMs = 10_000,
check?: (arg: A) => boolean,
arg?: A,
) {
const token = await this.inPage((p) => p.arm());
// Attach both handlers immediately: a failed trigger must not strand a rejecting page evaluation.
const done = this.inPage(
(p, a) => {
const condition = a.check ? new Function("arg", `return (${a.check})(arg)`) : null;
return p.waitShown(a.selector, a.text, a.timeoutMs, a.token, condition ? () => condition(a.arg) : undefined);
},
{ selector, text, timeoutMs, token, check: check?.toString(), arg },
).then(
(value) => ({ ok: true as const, value }),
(error: unknown) => ({ ok: false as const, error }),
);
try {
if ((await trigger()) === false) throw new Error("measurement trigger returned false");
const result = await done;
if (!result.ok) throw result.error;
return result.value;
} finally {
await this.inPage((p, token) => p.cancel(token), token);
}
/** Arms latency capture: the next input starts the clock, the paint showing `selector` stops it. */
async measure(trigger: () => Promise<unknown>, selector: string, text: string | null = null, timeoutMs = 10_000) {
await this.inPage((p) => p.arm());
const done = this.inPage((p, a) => p.waitShown(a.selector, a.text, a.timeoutMs), { selector, text, timeoutMs });
await trigger();
return done;
}
/**
* Types `text` one key at a time, `intervalMs` apart, recording keydown → next
* frame for each key. `\n` presses Enter, `\b` Backspace.
*/
async typeMeasured(text: string, intervalMs: number, target: "editor" | "input" = "editor"): Promise<number[]> {
const initial = await this.page.evaluate(readEditable, undefined);
if (initial.kind !== target) throw new Error(`typing focus is not in the expected ${target}`);
const characters = [...text];
let range: EditableRange | undefined;
let before = initial;
if (initial.kind === "editor") {
let from = initial.text.lastIndexOf("\n", initial.head - 1) + 1;
// A Backspace can cross at most one existing line; indentation deletion stays within it.
for (const character of characters) {
if (character === "\b" && from > 0) from = initial.text.lastIndexOf("\n", from - 2) + 1;
}
const nextLine = initial.text.indexOf("\n", Math.min(initial.text.length, initial.head + characters.length + 1));
const to = nextLine < 0 ? initial.text.length : nextLine + 1;
range = { from, to, length: initial.text.length };
const head = initial.head - from;
before = { ...initial, text: initial.text.slice(from, to), head, from: head, to: head };
}
const latencies = await this.pressMeasured(
characters.map((ch) => (ch === "\n" ? "Enter" : ch === "\b" ? "Backspace" : ch)),
async typeMeasured(text: string, intervalMs: number): Promise<number[]> {
return this.pressMeasured(
[...text].map((ch) => (ch === "\n" ? "Enter" : ch === "\b" ? "Backspace" : ch)),
intervalMs,
async (_, index) => {
const after = await this.page.evaluate(readEditable, range);
assertTypedKey(before, after, characters[index]!);
before = after;
},
);
const after = await this.page.evaluate(readEditable, range);
if (
after.kind !== before.kind ||
after.target !== before.target ||
after.text !== before.text ||
after.head !== before.head
) {
throw new Error("typing text or caret changed after the measured keys");
}
if (range) {
const final = await this.page.evaluate(readEditable, undefined);
const to = range.to + final.text.length - initial.text.length;
if (
final.kind !== initial.kind ||
final.target !== initial.target ||
final.head !== before.head + range.from ||
final.text.slice(0, range.from) !== initial.text.slice(0, range.from) ||
final.text.slice(range.from, to) !== before.text ||
final.text.slice(to) !== initial.text.slice(range.to)
) {
throw new Error("typing changed text outside the intended insertion or left an incorrect caret");
}
}
return latencies;
}
/** Presses `keys` `intervalMs` apart and returns keydown → next frame for each. */
async pressMeasured(
keys: string[],
intervalMs: number,
afterKey?: (key: string, index: number) => Promise<void>,
): Promise<number[]> {
async pressMeasured(keys: string[], intervalMs: number): Promise<number[]> {
await this.inPage((p) => {
p.keyLatencies = [];
p.recordKeys = true;
});
try {
for (const [index, key] of keys.entries()) {
const started = Date.now();
await this.page.keyboard.press(key);
await afterKey?.(key, index);
const wait = intervalMs - (Date.now() - started);
if (wait > 0) await this.page.waitForTimeout(wait);
}
await this.inPage((p) => p.afterNextPaint().then(() => p.afterNextPaint()));
const latencies = await this.inPage((p) => p.keyLatencies);
if (latencies.length !== keys.length || latencies.some((latency) => !Number.isFinite(latency) || latency < 0)) {
throw new Error(`key sample count mismatch: expected ${keys.length}, received ${latencies.length}`);
}
return latencies;
} finally {
await this.inPage((p) => {
p.recordKeys = false;
});
for (const key of keys) {
const started = Date.now();
await this.page.keyboard.press(key);
const wait = intervalMs - (Date.now() - started);
if (wait > 0) await this.page.waitForTimeout(wait);
}
}
/** Checks the actual selected option after every ArrowDown, including virtualized lists. */
async completionArrowsMeasured(count: number, intervalMs: number) {
const selection = () =>
this.page.evaluate(() => {
const selected = document.querySelector('.cm-tooltip-autocomplete li[aria-selected="true"]');
const index = selected?.id.match(/-(\d+)$/)?.[1];
if (!selected || index === undefined) throw new Error("completion selection is unavailable");
return { id: selected.id, index: Number(index) };
});
let before = await selection();
return this.pressMeasured(Array(count).fill("ArrowDown"), intervalMs, async () => {
const after = await selection();
if (after.id === before.id || after.index !== before.index + 1) {
throw new Error(`completion selection did not advance from ${before.index} to ${before.index + 1}`);
}
before = after;
// Let the last frames land.
await this.inPage((p) => p.afterNextPaint().then(() => p.afterNextPaint()));
return this.inPage((p) => {
p.recordKeys = false;
return p.keyLatencies;
});
}
/** A far jump must move both the active caret and its viewport to the document end. */
async jumpToEnd(timeoutMs = 5_000) {
await this.inPage((p) => p.afterNextPaint());
const start = await this.page.evaluate(() => {
const w = window as unknown as { __openideaPerf: EditorProbe };
const state = w.__openideaPerf.editorState();
const scroller = document.activeElement?.closest(".cm-editor")?.querySelector(".cm-scroller");
if (!state || !scroller || state.head === state.length || scroller.scrollHeight <= scroller.clientHeight) {
throw new Error("jump start must be outside the destination in a scrollable editor");
}
return { path: state.path, head: state.head, scrollTop: scroller.scrollTop };
});
return this.measure(
() => this.page.keyboard.press("ControlOrMeta+End"),
".cm-content",
null,
timeoutMs,
(start) => {
const w = window as unknown as { __openideaPerf: EditorProbe };
const state = w.__openideaPerf.editorState();
const editor = document.activeElement?.closest(".cm-editor");
const scroller = editor?.querySelector(".cm-scroller");
const bottom = scroller?.getBoundingClientRect().bottom;
return (
!!state &&
state.path === start.path &&
state.head === state.length &&
state.head !== start.head &&
!!scroller &&
scroller.scrollTop > start.scrollTop + scroller.clientHeight &&
bottom !== undefined &&
w.__openideaPerf.lineAtY(bottom - 4) === state.lines - 1
);
},
start,
);
}
/** Display refresh interval measured over idle frames. */
async refreshMs(): Promise<number> {
await this.inPage((p) => p.startFrames());
@@ -300,9 +162,20 @@ export class Harness {
}
/** Seeds a file into the in-memory backend and opens it, returning open → painted ms. */
async openFile(path: string, text?: string, timeoutMs = 15_000): Promise<number> {
async openFile(path: string, text?: string): Promise<number> {
if (text !== undefined) await this.seed(path, text);
return this.page.evaluate(openFileMeasured, { path, text, timeoutMs });
const name = path.slice(path.lastIndexOf("/") + 1);
return this.page.evaluate(
async ({ path, name }) => {
const w = window as never as { __perf: InPage; __openideaPerf: { openFile(p: string): Promise<void> } };
const t0 = performance.now();
void w.__openideaPerf.openFile(path);
await w.__perf.waitShown('[role="tab"][aria-selected="true"]', name, 15_000);
await w.__perf.waitShown(".cm-content .cm-line", null, 15_000);
return performance.now() - t0;
},
{ path, name },
);
}
/** Waits until the active editor's background parse has caught up (steady-state editing). */
@@ -322,9 +195,10 @@ export class Harness {
}
async editorState() {
return this.page.evaluate(() => {
const w = window as unknown as { __openideaPerf: EditorProbe };
return w.__openideaPerf.editorState();
});
return this.page.evaluate(() =>
(
window as never as { __openideaPerf: { editorState(): { length: number; lines: number; head: number } | null } }
).__openideaPerf.editorState(),
);
}
}
+19 -78
Переглянути файл
@@ -20,23 +20,16 @@ export interface InPage {
afterNextPaint(): Promise<number>;
startFrames(): void;
stopFrames(): number[];
/** Arms a current-input transition; unarmed waits remain navigation observations. */
arm(): number;
cancel(token: number): void;
waitShown(
selector: string,
text: string | null,
timeoutMs: number,
token?: number,
check?: () => boolean,
): Promise<number>;
/** Resolves with (frame start − first input after `arm`) once `selector` (and `text`) is rendered. */
arm(): void;
waitShown(selector: string, text: string | null, timeoutMs: number): Promise<number>;
}
export function installInPage() {
const w = window as unknown as { __perf: InPage };
if (w.__perf) return;
let nextToken = 0;
let operation: { token: number; input: number; capture?: () => void; cancel?: () => void } | null = null;
let armedAt = -1;
let firstInputAfterArm = -1;
const afterNextPaint = () =>
new Promise<number>((resolve) =>
@@ -50,10 +43,7 @@ export function installInPage() {
const onInput = (e: Event) => {
const t = e.timeStamp;
h.lastInput = t;
if (operation && operation.input < 0) {
operation.input = t;
operation.capture?.();
}
if (armedAt >= 0 && firstInputAfterArm < 0) firstInputAfterArm = t;
if (e.type === "keydown" && h.recordKeys) requestAnimationFrame(() => h.keyLatencies.push(performance.now() - t));
};
// `input` covers `keyboard.insertText`, which dispatches no keydown.
@@ -86,74 +76,25 @@ export function installInPage() {
return f;
},
arm() {
if (operation) throw new Error("a measurement is already armed");
const token = ++nextToken;
operation = { token, input: -1 };
return token;
armedAt = performance.now();
firstInputAfterArm = -1;
},
cancel(token) {
if (operation?.token !== token) return;
operation.cancel?.();
operation = null;
},
waitShown(selector, text, timeoutMs, token, check) {
const current = token === undefined ? null : operation;
if (token !== undefined && current?.token !== token) return Promise.reject(new Error("measurement is not armed"));
waitShown(selector, text, timeoutMs) {
const deadline = performance.now() + timeoutMs;
const snapshot = () => {
if (check && !check()) return [];
return [...document.querySelectorAll<HTMLElement>(selector)]
.filter(
(el) =>
el.getClientRects().length > 0 &&
getComputedStyle(el).visibility === "visible" &&
!el.closest('[aria-hidden="true"]') &&
(text === null || (el.textContent ?? "").includes(text)),
)
.map((el) => ({
el,
text: el.textContent,
value: el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement ? el.value : null,
selected: el.getAttribute("aria-selected"),
}));
const matches = () => {
const el = document.querySelector(selector) as HTMLElement | null;
if (!el || el.getClientRects().length === 0) return false;
return text === null || (el.textContent ?? "").includes(text);
};
let baseline = snapshot();
if (current)
current.capture = () => {
baseline = snapshot();
};
return new Promise<number>((resolve, reject) => {
let stopped = false;
const finish = () => {
stopped = true;
if (operation === current) operation = null;
};
if (current)
current.cancel = () => {
finish();
reject(new Error("measurement cancelled"));
};
const tick = () => {
if (stopped) return;
const frameStart = performance.now();
const shown = snapshot();
const changed = shown.some(
(now) =>
!baseline.some(
(old) =>
old.el === now.el &&
old.text === now.text &&
old.value === now.value &&
old.selected === now.selected,
),
);
// Keep the endpoint at frame start, but only credit this input's target transition.
if (shown.length && (!current || (current.input >= 0 && changed))) {
const start = current?.input ?? 0;
finish();
resolve(frameStart - start);
// Checked at the start of a frame: a match here is painted by this frame.
if (matches()) {
const start = firstInputAfterArm >= 0 ? firstInputAfterArm : armedAt;
armedAt = -1;
resolve(performance.now() - start);
} else if (performance.now() > deadline) {
finish();
armedAt = -1;
reject(new Error(`timed out waiting for ${selector}${text ? ` containing "${text}"` : ""}`));
} else requestAnimationFrame(tick);
};
-42
Переглянути файл
@@ -1,42 +0,0 @@
// @vitest-environment node
import { expect, test, vi } from "vitest";
import { launchBrowser, withDeadline } from "./lifecycle.ts";
test("a deadline rejects an unanswered operation and releases its timer", async () => {
vi.useFakeTimers();
try {
const pending = withDeadline(Promise.withResolvers<void>().promise, 20, "RPC");
const assertion = expect(pending).rejects.toThrow("RPC timed out after 20 ms");
await vi.advanceTimersByTimeAsync(20);
await assertion;
expect(vi.getTimerCount()).toBe(0);
} finally {
vi.useRealTimers();
}
});
test.each(["blocked renderer", "missing animation frames"])(
"Node deadline survives %s and browser cleanup terminates it",
{ timeout: 20_000 },
async (mode) => {
const runtime = await launchBrowser({ headless: true });
try {
const page = await runtime.browser.newPage();
// Real renderer/Node clocks are the boundary under test; fake timers cannot drive Chromium.
const operation =
mode === "blocked renderer"
? page.evaluate(() => {
for (;;) {
/* Deliberately unresponsive renderer. */
}
})
: page.evaluate(() => {
window.requestAnimationFrame = () => 0;
return new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
});
await expect(withDeadline(operation, 30, mode)).rejects.toThrow("wall clock");
} finally {
await runtime.close();
}
},
);
-59
Переглянути файл
@@ -1,59 +0,0 @@
import { chromium, type Browser, type LaunchOptions } from "@playwright/test";
import type { Server } from "node:http";
export class DeadlineError extends Error {
constructor(label: string, timeoutMs: number) {
super(`${label} timed out after ${timeoutMs} ms (wall clock)`);
this.name = "DeadlineError";
}
}
/** Runs on Node's clock even if the renderer, rAF, or an RPC never answers. */
export async function withDeadline<T>(operation: Promise<T>, timeoutMs: number, label: string): Promise<T> {
const { promise, reject } = Promise.withResolvers<never>();
const timer = setTimeout(() => reject(new DeadlineError(label, timeoutMs)), timeoutMs);
try {
return await Promise.race([operation, promise]);
} finally {
clearTimeout(timer);
}
}
export interface BrowserSession {
browser: Browser;
close(): Promise<void>;
}
export async function launchBrowser(options: LaunchOptions, cleanupMs = 5000): Promise<BrowserSession> {
const server = await chromium.launchServer({ ...options, timeout: 30_000 });
const close = async () => {
try {
await withDeadline(server.close(), cleanupMs, "browser close");
} catch (error) {
try {
await withDeadline(server.kill(), cleanupMs, "browser kill");
} catch (killError) {
throw new AggregateError([error, killError], "Browser cleanup failed", { cause: killError });
}
throw error;
}
};
try {
const browser = await chromium.connect(server.wsEndpoint(), { timeout: 30_000 });
return { browser, close };
} catch (error) {
try {
await close();
} catch (cleanup) {
throw new AggregateError([error, cleanup], "Browser startup failed", { cause: cleanup });
}
throw error;
}
}
export async function closeServer(server: Server) {
server.closeAllConnections();
const { promise, resolve, reject } = Promise.withResolvers<void>();
server.close((error) => (error ? reject(error) : resolve()));
await withDeadline(promise, 5000, "HTTP server close");
}
-47
Переглянути файл
@@ -1,47 +0,0 @@
import { spawnSync } from "node:child_process";
import { resolve } from "node:path";
import { describe, expect, it } from "vitest";
import { countOption } from "./options.ts";
const root = resolve(import.meta.dirname, "../..");
describe("benchmark CLI validation", () => {
it.each([
["runs", "NaN"],
["runs", "Infinity"],
["runs", "0"],
["runs", "1.5"],
["warmup", "-1"],
["warmup", "NaN"],
["warmup", "0.5"],
["cpu", "NaN"],
["cpu", "Infinity"],
["cpu", "0"],
])("rejects --%s %s before selecting or launching workloads", (option, value) => {
const result = spawnSync(
process.execPath,
["perf/run.ts", "--no-build", "--only", "__unknown__", `--${option}=${value}`],
{ cwd: root, encoding: "utf8", timeout: 10_000 },
);
expect(result.status).toBe(1);
expect(result.stderr).toContain(`--${option} must be`);
expect(result.stdout).not.toContain("Building");
});
it.each(["typing,__unknown__", "", "typing,"])("rejects invalid selection %j", (selection) => {
const result = spawnSync(process.execPath, ["perf/run.ts", "--no-build", "--only", selection], {
cwd: root,
encoding: "utf8",
timeout: 10_000,
});
expect(result.status).toBe(1);
expect(result.stderr).toContain("unknown scenario(s)");
});
it("accepts integral counts and zero warmup without silently clamping", () => {
expect(countOption("runs", "5", 1)).toBe(5);
expect(countOption("warmup", "0", 0)).toBe(0);
expect(() => countOption("warmup", "", 0)).toThrow();
expect(() => countOption("runs", "9007199254740992", 1)).toThrow();
});
});
-8
Переглянути файл
@@ -1,8 +0,0 @@
/** CLI repetition counts must be validated before any build or process launch. */
export function countOption(name: string, raw: string, minimum: 0 | 1): number {
const value = Number(raw);
if (!raw.trim() || !Number.isSafeInteger(value) || value < minimum) {
throw new Error(`--${name} must be an integer >= ${minimum}`);
}
return value;
}
-106
Переглянути файл
@@ -1,106 +0,0 @@
/// <reference lib="es2024.promise" />
import { spawn, type ChildProcess, type StdioOptions } from "node:child_process";
/** Run one owned command and bound both execution and process-tree cleanup. */
export async function runCommand(
command: string,
args: string[],
options: {
cwd: string;
env?: NodeJS.ProcessEnv;
timeoutMs: number;
label?: string;
graceMs?: number;
stdio?: StdioOptions;
},
): Promise<void> {
const label = options.label ?? command;
const graceMs = options.graceMs ?? 1000;
if (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0 || options.timeoutMs > 2_147_483_647) {
throw new Error(`${label}: invalid execution deadline`);
}
if (!Number.isFinite(graceMs) || graceMs <= 0 || graceMs > 2_147_483_647) {
throw new Error(`${label}: invalid cleanup deadline`);
}
const child = spawn(command, args, {
cwd: options.cwd,
env: options.env,
detached: process.platform !== "win32",
shell: process.platform === "win32" && /\.(cmd|bat)$/i.test(command),
stdio: options.stdio ?? "inherit",
});
const { promise, resolve, reject } = Promise.withResolvers<void>();
const errors: string[] = [];
let stopping = false;
let finished = false;
let cleanup: NodeJS.Timeout | undefined;
let treeKiller: ChildProcess | undefined;
const group = process.platform !== "win32";
const alive = () => {
if (!child.pid) return false;
try {
process.kill(group ? -child.pid : child.pid, 0);
return true;
} catch (error) {
return (error as NodeJS.ErrnoException).code !== "ESRCH";
}
};
const signal = (value: NodeJS.Signals) => {
if (!child.pid) return;
try {
if (group) process.kill(-child.pid, value);
else child.kill(value);
} catch (error) {
if ((error as NodeJS.ErrnoException).code !== "ESRCH") {
errors.push(`cleanup: ${error instanceof Error ? error.message : String(error)}`);
}
}
};
const finish = () => {
if (finished) return;
finished = true;
clearTimeout(deadline);
clearTimeout(cleanup);
treeKiller?.kill("SIGKILL");
treeKiller?.unref();
process.removeListener("SIGINT", interrupt);
process.removeListener("SIGTERM", terminate);
// Never wait indefinitely for an uninterruptible process or inherited pipe.
child.unref();
child.stdout?.destroy();
child.stderr?.destroy();
if (errors.length) reject(new Error(`${label}: ${errors.join("; ")}`));
else resolve();
};
const stop = (error?: string) => {
if (error) errors.push(error);
if (stopping) return;
stopping = true;
clearTimeout(deadline);
if (!alive()) return finish();
if (!group && child.pid) {
// Windows has no POSIX process groups. Bound this PID-scoped taskkill too.
treeKiller = spawn("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" });
treeKiller.on("error", (failure) => errors.push(`tree cleanup: ${failure.message}`));
} else signal("SIGTERM");
cleanup = setTimeout(() => {
signal("SIGKILL");
cleanup = setTimeout(() => {
if (alive()) errors.push("process group remained after SIGKILL");
finish();
}, graceMs);
}, graceMs);
};
const interrupt = () => stop("interrupted by SIGINT");
const terminate = () => stop("interrupted by SIGTERM");
const deadline = setTimeout(() => stop(`timed out after ${options.timeoutMs} ms`), options.timeoutMs);
process.on("SIGINT", interrupt);
process.on("SIGTERM", terminate);
child.once("error", (error) => stop(`spawn failed: ${error.message}`));
child.once("exit", (code, exitSignal) => {
if (code !== 0 && !errors.length) errors.push(`failed (exit ${code}, signal ${exitSignal})`);
if (!stopping) stop();
else if (!alive()) finish();
});
return promise;
}
+2 -42
Переглянути файл
@@ -32,7 +32,6 @@ describe("evaluate", () => {
it("fails metrics over budget and budgeted metrics that are missing", () => {
const r = evaluate(results, { "typing.maxMs": 33, "typing.missedFramePct": 2, "other.x": 1 }, null, {
enforceBudgets: true,
expected: ["typing"],
});
expect(r.rows.find((x) => x.key === "typing.maxMs")?.verdict).toBe("over-budget");
expect(r.rows.find((x) => x.key === "typing.missedFramePct")?.verdict).toBe("error");
@@ -42,57 +41,18 @@ describe("evaluate", () => {
});
it("reports but does not fail budgets when not enforced", () => {
const r = evaluate(results, { "typing.maxMs": 33 }, null, { enforceBudgets: false, expected: ["typing"] });
const r = evaluate(results, { "typing.maxMs": 33 }, null, { enforceBudgets: false });
expect(r.rows.find((x) => x.key === "typing.maxMs")?.verdict).toBe("over-budget-info");
expect(r.failures).toBe(0);
});
it("compares against the baseline with relative and absolute slack", () => {
const baseline = [{ id: "typing", title: "", metrics: { p95Ms: 14, maxMs: 39.5, layoutsPerKey: 2 } }];
const r = evaluate(results, {}, baseline, {
enforceBudgets: true,
expected: ["typing"],
tolerance: 0.2,
floor: 1,
});
const r = evaluate(results, {}, baseline, { enforceBudgets: true, tolerance: 0.2, floor: 1 });
const verdict = (k: string) => r.rows.find((x) => x.key === k)?.verdict;
expect(verdict("typing.p95Ms")).toBe("regressed"); // +28 %, +4 ms
expect(verdict("typing.maxMs")).toBe("ok"); // within 20 %
expect(verdict("typing.layoutsPerKey")).toBe("ok"); // +50 % but only +1 (floor)
expect(r.regressions).toBe(1);
});
it("fails when a declared scenario disappears from the results", () => {
const report = evaluate(results, { "scroll.jumpMs": 50 }, null, {
enforceBudgets: true,
expected: ["typing", "scroll"],
});
expect(report.errors).toContainEqual({ id: "scroll", error: "missing scenario result" });
expect(report.rows.find((r) => r.key === "scroll.jumpMs")?.verdict).toBe("error");
expect(report.failures).toBeGreaterThan(0);
});
it("rejects duplicate and unexpected scenario results", () => {
const report = evaluate([...results, ...results, { id: "other", title: "", metrics: { ms: 1 } }], {}, null, {
enforceBudgets: true,
expected: ["typing"],
});
expect(report.errors).toEqual([
{ id: "typing", error: "duplicate scenario result" },
{ id: "other", error: "unexpected scenario result" },
]);
});
it("rejects an empty workload instead of returning a passing report", () => {
expect(evaluate([], {}, null, { enforceBudgets: true, expected: [] }).failures).toBeGreaterThan(0);
});
it("fails nonfinite metrics even without an absolute budget", () => {
const report = evaluate([{ id: "typing", title: "", metrics: { ms: Infinity } }], {}, null, {
enforceBudgets: false,
expected: ["typing"],
});
expect(report.rows[0]?.verdict).toBe("error");
expect(report.failures).toBe(1);
});
});
+5 -21
Переглянути файл
@@ -52,7 +52,7 @@ export function evaluate(
results: ScenarioResult[],
budgets: Record<string, number>,
baseline: ScenarioResult[] | null,
opts: { expected: readonly string[]; enforceBudgets: boolean; tolerance?: number; floor?: number },
opts: { enforceBudgets: boolean; tolerance?: number; floor?: number },
): Report {
const tol = opts.tolerance ?? 0.2;
const floor = opts.floor ?? 1;
@@ -62,21 +62,7 @@ export function evaluate(
const rows: Row[] = [];
const errors: Report["errors"] = [];
const seen = new Set<string>();
const expected = new Set(opts.expected);
const produced = new Set<string>();
if (!expected.size) errors.push({ id: "run", error: "empty workload" });
if (expected.size !== opts.expected.length) errors.push({ id: "run", error: "duplicate expected scenario" });
for (const r of results) {
if (!expected.has(r.id)) {
errors.push({ id: r.id, error: "unexpected scenario result" });
continue;
}
if (produced.has(r.id)) {
errors.push({ id: r.id, error: "duplicate scenario result" });
continue;
}
produced.add(r.id);
if (!r.error && !Object.keys(r.metrics).length) errors.push({ id: r.id, error: "no metrics produced" });
if (r.error) errors.push({ id: r.id, error: r.error });
for (const [m, value] of Object.entries(r.metrics)) {
const key = `${r.id}.${m}`;
@@ -84,7 +70,7 @@ export function evaluate(
const budget = budgets[key];
const before = base.get(key);
let verdict: Verdict = "ok";
if (!Number.isFinite(value)) verdict = "error";
if (!Number.isFinite(value)) verdict = budget === undefined ? "ok" : "error";
else if (budget !== undefined && value > budget)
verdict = opts.enforceBudgets ? "over-budget" : "over-budget-info";
else if (before !== undefined && value > before * (1 + tol) && value - before > floor) verdict = "regressed";
@@ -92,12 +78,10 @@ export function evaluate(
rows.push({ key, value, budget, baseline: before, verdict });
}
}
for (const id of expected) {
if (!produced.has(id)) errors.push({ id, error: "missing scenario result" });
}
// Required metrics are scoped by the declared workload, never by returned data.
// A budgeted metric that was not produced (scenario failed or renamed) fails too.
const ran = new Set(results.map((r) => r.id));
for (const key of Object.keys(budgets)) {
if (!seen.has(key) && expected.has(key.slice(0, key.indexOf(".")))) {
if (!seen.has(key) && ran.has(key.slice(0, key.indexOf(".")))) {
rows.push({ key, value: NaN, budget: budgets[key], verdict: "error" });
}
}
-58
Переглянути файл
@@ -1,58 +0,0 @@
// @vitest-environment node
import { spawnSync } from "node:child_process";
import { cpSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join, resolve } from "node:path";
import { expect, test } from "vitest";
const repo = resolve(import.meta.dirname, "../..");
test.each([
{ family: "perf", args: ["--only", "typing", "--no-build"], kind: "missing bundle" },
{ family: "perf", args: ["--only", "typing"], kind: "build failure" },
{ family: "perf", args: ["--only", "typing", "--no-build", "--channel", "not-a-browser"], kind: "browser failure" },
{ family: "evals", args: ["--only", "java.app", "--no-build"], kind: "missing server" },
])("$kind replaces old passing reports with structured failure", { timeout: 30_000 }, ({ family, args, kind }) => {
const root = mkdtempSync(join(tmpdir(), "openidea-runner-failure-"));
try {
for (const dir of ["perf", "evals", "smoke"]) cpSync(join(repo, dir), join(root, dir), { recursive: true });
cpSync(join(repo, "package.json"), join(root, "package.json"));
symlinkSync(join(repo, "node_modules"), join(root, "node_modules"), "junction");
const output = join(root, "target", family === "perf" ? "perf" : "eval");
mkdirSync(output, { recursive: true });
writeFileSync(join(output, "report.json"), '{"pass":true,"sentinel":"old success"}');
writeFileSync(join(output, "report.md"), "old success");
if (kind === "browser failure") {
mkdirSync(join(output, "dist"));
writeFileSync(join(output, "dist", "index.html"), "<!doctype html><title>launch boundary</title>");
}
const result = spawnSync(
process.execPath,
[join(root, family, "run.ts"), ...args, "--runs", "1", "--warmup", "0"],
{
encoding: "utf8",
timeout: 20_000,
env: {
...process.env,
PATH: kind === "build failure" ? "" : process.env.PATH,
OPENIDEA_SERVER: join(root, "nonexistent-server"),
},
},
);
expect(result.error).toBeUndefined();
expect(result.status, result.stderr).toBe(1);
const report = JSON.parse(readFileSync(join(output, "report.json"), "utf8"));
expect(report.status).toBe("failed");
expect(report.infrastructure.length).toBeGreaterThan(0);
expect(report.expected.length).toBeGreaterThan(0);
expect(report.trials).toEqual({});
expect(report.sentinel).toBeUndefined();
if (family === "evals") expect(report.pass).toBe(false);
else expect(report.failures).toBeGreaterThan(0);
const markdown = readFileSync(join(output, "report.md"), "utf8");
expect(markdown).not.toContain("old success");
expect(markdown).toMatch(/Infrastructure|infrastructure/);
} finally {
rmSync(root, { recursive: true, force: true });
}
});
-200
Переглянути файл
@@ -1,200 +0,0 @@
import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, utimesSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join, resolve } from "node:path";
import { afterEach, describe, expect, it } from "vitest";
import {
collectRustMetrics,
inspectRustArtifacts,
RUST_BENCHMARKS,
rustBudgets,
rustPaths,
selectRustPackages,
} from "./rust.ts";
import { runRust } from "./rustRun.ts";
const TEXT_BENCHMARKS = RUST_BENCHMARKS["ide-text"]!.length;
const roots: string[] = [];
function fixture() {
const root = mkdtempSync(join(tmpdir(), "rust-validity-"));
roots.push(root);
return root;
}
function artifact(root: string, id: string, value: unknown = 1000, directory = id) {
const dir = join(root, directory, "new");
mkdirSync(dir, { recursive: true });
writeFileSync(join(dir, "benchmark.json"), JSON.stringify({ full_id: id }));
writeFileSync(join(dir, "estimates.json"), JSON.stringify({ mean: { point_estimate: value } }));
return dir;
}
function complete(root: string, packages: readonly string[]) {
for (const p of packages) for (const id of RUST_BENCHMARKS[p]!) artifact(root, id);
}
afterEach(() => {
for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
});
describe("Rust workload contract", () => {
it("owns 40 unique IDs and exactly six observe-only metrics", () => {
const ids = Object.values(RUST_BENCHMARKS).flat();
expect(ids).toHaveLength(40);
expect(new Set(ids).size).toBe(40);
const budgets = JSON.parse(readFileSync(resolve(import.meta.dirname, "../budgets.json"), "utf8")).rust;
const selected = rustBudgets(selectRustPackages(), budgets);
expect(Object.keys(selected)).toHaveLength(34);
expect(ids.filter((id) => !(id in budgets))).toEqual([
"syntax_2mb/outline_uncached",
"syntax_2mb/folding_uncached",
"index_100k/find_files/zzzz",
"index_100k/find_symbols/renderView",
"startup_20k/reopen_wait_idle",
"search_excluded_subtrees/5k_dependencies",
]);
expect(Object.keys(rustBudgets(["ide-text"], budgets))).toHaveLength(9);
const missing = { ...budgets };
delete missing["text/open_1mb"];
expect(() => rustBudgets(["ide-text"], missing)).toThrow(/classification/);
expect(() => rustBudgets(["ide-text"], { ...budgets, "text/new": 1 })).toThrow(/unknown/);
expect(() => rustBudgets(["ide-text"], { ...budgets, "syntax_2mb/outline_uncached": 1 })).toThrow(/observe-only/);
});
it("rejects unknown or empty packages and deduplicates before cargo", () => {
expect(() => selectRustPackages([])).toThrow(/empty/);
expect(() => selectRustPackages([""])).toThrow(/unknown/);
expect(() => selectRustPackages(["not-a-crate"])).toThrow(/unknown/);
expect(selectRustPackages(["ide-text", "ide-text"])).toEqual(["ide-text"]);
});
it("reports unknown packages without invoking cargo", async () => {
const root = fixture();
const marker = join(root, "cargo-invoked");
writeFileSync(join(root, "cargo"), `#!/bin/sh\n: > '${marker}'\nexit 99\n`, { mode: 0o755 });
const code = await runRust({
root,
packages: ["not-a-crate"],
env: { ...process.env, PATH: root },
});
expect(code).toBe(1);
const report = JSON.parse(readFileSync(join(root, "target/perf/report-rust.json"), "utf8"));
expect(report.errors[0].error).toMatch(/unknown Rust package/);
expect(existsSync(marker)).toBe(false);
});
it("resolves target and Criterion overrides relative to cargo's cwd", () => {
expect(rustPaths("/work", {})).toEqual({ target: "/work/target", criterion: "/work/target/criterion" });
expect(rustPaths("/work", { CARGO_TARGET_DIR: "private" })).toEqual({
target: "/work/private",
criterion: "/work/private/criterion",
});
expect(rustPaths("/work", { CARGO_TARGET_DIR: "/private", CRITERION_HOME: "results" })).toEqual({
target: "/private",
criterion: "/work/results",
});
});
it("accepts a complete full workload and converts nanoseconds to microseconds", () => {
const root = fixture();
complete(root, selectRustPackages());
expect(Object.keys(collectRustMetrics(root, selectRustPackages()))).toHaveLength(40);
expect(collectRustMetrics(root, ["ide-text"])["text/open_1mb"]).toBe(1);
});
it("requires selected IDs independently of budgets, including observe-only IDs", () => {
const root = fixture();
expect(() => collectRustMetrics(root, ["ide-text"])).toThrow(/missing/);
complete(root, ["ide-language"]);
rmSync(join(root, "syntax_2mb/outline_uncached"), { recursive: true });
expect(() => collectRustMetrics(root, ["ide-language"])).toThrow(/outline_uncached/);
expect(() => collectRustMetrics(root, selectRustPackages())).toThrow(/missing/);
});
it.each([
["ide-language", "syntax_2mb/outline_uncached"],
["ide-language", "syntax_2mb/folding_uncached"],
["ide-index", "index_100k/find_files/zzzz"],
["ide-index", "index_100k/find_symbols/renderView"],
["ide-index", "startup_20k/reopen_wait_idle"],
["ide-search", "search_excluded_subtrees/5k_dependencies"],
])("requires observe-only metric %s / %s", (p, id) => {
const root = fixture();
complete(root, [p]);
rmSync(join(root, id), { recursive: true });
expect(() => collectRustMetrics(root, [p])).toThrow(/missing selected/);
});
it("ignores known unselected artifacts, including their malformed estimates", () => {
const root = fixture();
complete(root, ["ide-text"]);
artifact(root, "heap/index_1m_objects", "bad");
const unrelated = artifact(root, "heap/dominators_1m_random");
writeFileSync(join(unrelated, "benchmark.json"), "{");
expect(Object.keys(collectRustMetrics(root, ["ide-text"]))).toHaveLength(TEXT_BENCHMARKS);
});
it("rejects duplicate IDs and unknown selected IDs even with complete expected results", () => {
const root = fixture();
complete(root, ["ide-text"]);
artifact(root, "text/open_1mb", 1000, "duplicate");
expect(() => collectRustMetrics(root, ["ide-text"])).toThrow(/duplicate/);
rmSync(join(root, "duplicate"), { recursive: true });
artifact(root, "text/renamed");
expect(() => collectRustMetrics(root, ["ide-text"])).toThrow(/unknown/);
});
it.each([null, "1000", -1, {}])("rejects invalid means: %j", (value) => {
const root = fixture();
complete(root, ["ide-text"]);
artifact(root, "text/open_1mb", value);
expect(() => collectRustMetrics(root, ["ide-text"])).toThrow(/estimate/);
});
it("accepts zero and rejects malformed metadata, absent estimates, and invalid JSON", () => {
const root = fixture();
complete(root, ["ide-text"]);
const dir = artifact(root, "text/open_1mb", 0);
expect(collectRustMetrics(root, ["ide-text"])["text/open_1mb"]).toBe(0);
writeFileSync(join(dir, "benchmark.json"), "{}");
expect(() => collectRustMetrics(root, ["ide-text"])).toThrow(/full_id/);
artifact(root, "text/open_1mb");
rmSync(join(dir, "estimates.json"));
expect(() => collectRustMetrics(root, ["ide-text"])).toThrow();
writeFileSync(join(dir, "estimates.json"), "{");
expect(() => collectRustMetrics(root, ["ide-text"])).toThrow();
writeFileSync(join(dir, "estimates.json"), "{}");
expect(() => collectRustMetrics(root, ["ide-text"])).toThrow(/estimate/);
});
it.each(["benchmark.json", "estimates.json"])("requires fresh %s for a newly run workload", (file) => {
const root = fixture();
complete(root, ["ide-text"]);
const dir = artifact(root, "text/open_1mb");
utimesSync(join(dir, file), new Date(0), new Date(0));
expect(() => collectRustMetrics(root, ["ide-text"], 1)).toThrow(/stale/);
expect(Object.keys(collectRustMetrics(root, ["ide-text"]))).toHaveLength(TEXT_BENCHMARKS);
});
it("rejects overflowing JSON numeric estimates, including observe-only metrics", () => {
const root = fixture();
complete(root, ["ide-language"]);
const dir = artifact(root, "syntax_2mb/outline_uncached");
writeFileSync(join(dir, "estimates.json"), '{"mean":{"point_estimate":1e309}}');
expect(() => collectRustMetrics(root, ["ide-language"])).toThrow(/estimate/);
});
it.each(["benchmark.json", "estimates.json"])("rejects future %s even in inspection mode", (file) => {
const root = fixture();
complete(root, ["ide-text"]);
const date = new Date(Date.now() + 60_000);
utimesSync(join(root, "text/open_1mb/new", file), date, date);
expect(() => collectRustMetrics(root, ["ide-text"])).toThrow(/future Criterion artifact/);
});
it("retains partial valid metrics and dated artifacts after malformed selected output", () => {
const root = fixture();
complete(root, ["ide-text"]);
writeFileSync(join(root, "text/open_1mb/new/estimates.json"), "{");
const result = inspectRustArtifacts(root, ["ide-text"]);
expect(Object.keys(result.metrics)).toHaveLength(TEXT_BENCHMARKS - 1);
expect(result.errors.length).toBeGreaterThan(0);
expect(result.artifacts).toContainEqual(expect.objectContaining({ path: "text/open_1mb/new/benchmark.json" }));
});
});
-190
Переглянути файл
@@ -1,190 +0,0 @@
import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
import { join, relative, resolve, sep } from "node:path";
// Package-owned expectations, independent of collected artifacts and human-owned budgets.
export const RUST_BENCHMARKS: Readonly<Record<string, readonly string[]>> = {
"ide-text": [
"text/open_1mb",
"text/apply_keystroke_1mb",
"text/apply_100_changes_1mb",
"text/diff_two_edits_1mb",
"text/diff_every_line_1mb",
"text/offset_to_pos_round_trip",
"text/pos_to_byte",
"text/text_for_save_crlf_1mb",
"text/diff_one_edit_5mb",
],
"ide-language": [
"syntax_2mb/outline_uncached",
"syntax_2mb/folding_uncached",
"syntax_2mb/outline_cached_hit",
"syntax_2mb/folding_cached_hit",
"syntax_2mb/selection_cached_hit",
"syntax_2mb/folding_after_keystroke_incremental",
"syntax_2mb/outline_after_keystroke_incremental",
],
"ide-index": [
"index_100k/find_files/ordcon",
"index_100k/find_files/src/user",
"index_100k/find_files/PaymentService",
"index_100k/find_files/zzzz",
"index_100k/find_files/a",
"index_100k/find_dirs/util",
"index_100k/find_dirs/src/ui",
"index_100k/find_dirs/a",
"index_100k/find_symbols/OCo",
"index_100k/find_symbols/invoiceRepo",
"index_100k/find_symbols/renderView",
"index_100k/find_symbols/q",
"index_100k/find_symbols_types/UsSe",
"startup_20k/reopen_wait_idle",
],
"ide-search": [
"search_5k/literal",
"search_5k/regex",
"search_5k/dense_limit",
"search_dense_files/24x40k_limit",
"search_excluded_subtrees/5k_dependencies",
],
"ide-host": ["plugins/load_50", "plugins/cold_activation", "plugins/syntax_highlights_2k_lines"],
"ide-heap": ["heap/index_1m_objects", "heap/dominators_1m_random"],
};
const OBSERVE_ONLY: Readonly<Record<string, true>> = {
"syntax_2mb/outline_uncached": true,
"syntax_2mb/folding_uncached": true,
"index_100k/find_files/zzzz": true,
"index_100k/find_symbols/renderView": true,
"startup_20k/reopen_wait_idle": true,
"search_excluded_subtrees/5k_dependencies": true,
};
export function selectRustPackages(packages: readonly string[] = Object.keys(RUST_BENCHMARKS)): string[] {
if (packages.length === 0) throw new Error("empty Rust package selection");
for (const p of packages) {
if (!Object.hasOwn(RUST_BENCHMARKS, p)) throw new Error(`unknown Rust package: ${JSON.stringify(p)}`);
}
return [...new Set(packages)];
}
export function rustPaths(root: string, env: { CARGO_TARGET_DIR?: string; CRITERION_HOME?: string }) {
const target = resolve(root, env.CARGO_TARGET_DIR ?? "target");
return { target, criterion: resolve(root, env.CRITERION_HOME ?? join(target, "criterion")) };
}
export function rustBudgets(packages: readonly string[], budgets: Record<string, number>): Record<string, number> {
const selected = selectRustPackages(packages);
const ids = new Set(Object.values(RUST_BENCHMARKS).flat());
for (const id of Object.keys(OBSERVE_ONLY)) {
if (!ids.has(id)) throw new Error(`unknown Rust observe-only classification: ${id}`);
}
for (const [id, value] of Object.entries(budgets)) {
if (!ids.has(id)) throw new Error(`unknown Rust budget ID: ${id}`);
if (Object.hasOwn(OBSERVE_ONLY, id)) throw new Error(`Rust observe-only ID has an absolute budget: ${id}`);
if (!Number.isFinite(value) || value < 0) throw new Error(`invalid Rust budget: ${id}`);
}
for (const id of ids) {
if (!Object.hasOwn(budgets, id) && !Object.hasOwn(OBSERVE_ONLY, id)) {
throw new Error(`missing Rust budget classification: ${id}`);
}
}
return Object.fromEntries(
selected
.flatMap((p) => RUST_BENCHMARKS[p]!)
.filter((id) => !Object.hasOwn(OBSERVE_ONLY, id))
.map((id) => [`rust.${id}`, budgets[id]!]),
);
}
export interface RustArtifacts {
metrics: Record<string, number>;
artifacts: Array<{ path: string; modifiedAt: string }>;
errors: string[];
}
/** Keep valid partial results and file dates even when another selected artifact is invalid. */
export function inspectRustArtifacts(
dir: string,
packages: readonly string[],
started?: number,
now = Date.now(),
): RustArtifacts {
const selected = new Set(selectRustPackages(packages));
const expected = new Set([...selected].flatMap((p) => RUST_BENCHMARKS[p]!));
const owners = new Map<string, string>();
const groups = new Map<string, string>();
for (const [p, ids] of Object.entries(RUST_BENCHMARKS)) {
for (const id of ids) {
owners.set(id, p);
groups.set(id.split("/")[0]!, p);
}
}
const metrics: Record<string, number> = {};
const artifacts: RustArtifacts["artifacts"] = [];
const errors: string[] = [];
const seen = new Set<string>();
function readNew(sub: string) {
// Criterion sanitizes slashes in ungrouped function names to underscores.
const top = relative(dir, sub).split(sep)[0]!;
const pathOwner = [...groups].find(([group]) => top === group || top.startsWith(`${group}_`))?.[1];
if (pathOwner && !selected.has(pathOwner)) return;
const bench = join(sub, "new", "benchmark.json");
const estimates = join(sub, "new", "estimates.json");
if (!existsSync(bench)) {
if (existsSync(estimates) && (!pathOwner || selected.has(pathOwner))) {
throw new Error(`missing Criterion benchmark.json: ${sub}`);
}
return;
}
const metadata: unknown = JSON.parse(readFileSync(bench, "utf8"));
const id = metadata && typeof metadata === "object" && "full_id" in metadata ? metadata.full_id : undefined;
if (typeof id !== "string" || !id) {
throw new Error(`invalid Criterion full_id: ${bench}`);
}
const owner = owners.get(id) ?? groups.get(id.split("/")[0]!);
if (owner && !selected.has(owner)) return;
if (!expected.has(id)) throw new Error(`unknown selected Criterion ID: ${id}`);
if (seen.has(id)) throw new Error(`duplicate Criterion ID: ${id}`);
seen.add(id);
for (const file of [bench, estimates]) {
const modified = statSync(file).mtimeMs;
artifacts.push({ path: relative(dir, file), modifiedAt: new Date(modified).toISOString() });
// Allow filesystem timestamp rounding, not future-dated benchmark results.
if (modified > now + 1000) throw new Error(`future Criterion artifact: ${file}`);
if (started !== undefined && modified < started) throw new Error(`stale Criterion artifact: ${file}`);
}
const est: unknown = JSON.parse(readFileSync(estimates, "utf8"));
const mean = est && typeof est === "object" && "mean" in est ? est.mean : undefined;
const value = mean && typeof mean === "object" && "point_estimate" in mean ? mean.point_estimate : undefined;
if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
throw new Error(`invalid Criterion mean estimate: ${estimates}`);
}
metrics[id] = value / 1000;
}
function visit(path: string) {
try {
if (!existsSync(path)) return;
try {
readNew(path);
} catch (error) {
errors.push(error instanceof Error ? error.message : String(error));
}
for (const entry of readdirSync(path, { withFileTypes: true })) {
if (entry.isDirectory() && !["new", "base", "report"].includes(entry.name)) visit(join(path, entry.name));
}
} catch (error) {
errors.push(error instanceof Error ? error.message : String(error));
}
}
visit(dir);
const missing = [...expected].filter((id) => !Object.hasOwn(metrics, id));
if (missing.length) errors.push(`missing selected Criterion IDs: ${missing.join(", ")}`);
return { metrics, artifacts, errors };
}
/** Strict convenience interface for consumers that require the complete selected workload. */
export function collectRustMetrics(dir: string, packages: readonly string[], started?: number): Record<string, number> {
const result = inspectRustArtifacts(dir, packages, started);
if (result.errors.length) throw new Error(result.errors.join("\n"));
return result.metrics;
}
-234
Переглянути файл
@@ -1,234 +0,0 @@
import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, utimesSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join, resolve } from "node:path";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { RUST_BENCHMARKS } from "./rust.ts";
import { runRust } from "./rustRun.ts";
const TEXT_BENCHMARKS = RUST_BENCHMARKS["ide-text"]!.length;
const roots: string[] = [];
const ownedPids: number[] = [];
beforeEach(() => {
vi.stubEnv("CARGO_TARGET_DIR", "target");
vi.stubEnv("CRITERION_HOME", "target/criterion");
});
function fixture() {
const root = mkdtempSync(join(tmpdir(), "rust-run-"));
roots.push(root);
mkdirSync(join(root, "perf"));
writeFileSync(join(root, "perf/budgets.json"), readFileSync(resolve(import.meta.dirname, "../budgets.json")));
mkdirSync(join(root, "target/perf"), { recursive: true });
writeFileSync(join(root, "target/perf/report-rust.json"), '{"sentinel":"old passing report"}');
writeFileSync(join(root, "target/perf/report-rust.md"), "old passing report");
return root;
}
function report(root: string) {
return JSON.parse(readFileSync(join(root, "target/perf/report-rust.json"), "utf8"));
}
function artifacts(root: string, packages: readonly string[], date = new Date()) {
for (const p of packages)
for (const id of RUST_BENCHMARKS[p]!) {
const directory = join(root, id, "new");
mkdirSync(directory, { recursive: true });
for (const [file, content] of [
["benchmark.json", { full_id: id }],
["estimates.json", { mean: { point_estimate: 1 } }],
] as const) {
const path = join(directory, file);
writeFileSync(path, JSON.stringify(content));
utimesSync(path, date, date);
}
}
}
function recorded(root: string, id: string, packages: string[], started: number, error?: string) {
const runRoot = join(root, "target/criterion/runs", id);
mkdirSync(runRoot, { recursive: true });
writeFileSync(
join(runRoot, "run.json"),
JSON.stringify({
id,
packages,
startedAt: new Date(started).toISOString(),
finishedAt: new Date(started + 5000).toISOString(),
...(error ? { error } : {}),
}),
);
artifacts(join(runRoot, "criterion"), packages, new Date(started + 1000));
return runRoot;
}
function childCommand(tail: string, ids = RUST_BENCHMARKS["ide-text"]!) {
return {
file: process.execPath,
args: [
"-e",
`
const fs = require('node:fs');
const path = require('node:path');
for (const id of ${JSON.stringify(ids)}) {
const directory = path.join(process.env.CRITERION_HOME, id, 'new');
fs.mkdirSync(directory, { recursive: true });
fs.writeFileSync(path.join(directory, 'benchmark.json'), JSON.stringify({full_id:id}));
fs.writeFileSync(path.join(directory, 'estimates.json'), JSON.stringify({mean:{point_estimate:1}}));
}
console.error('partial cargo evidence');
${tail}
`,
],
};
}
afterEach(() => {
vi.unstubAllEnvs();
for (const pid of ownedPids.splice(0)) {
try {
process.kill(pid, "SIGKILL");
} catch (error) {
if ((error as NodeJS.ErrnoException).code !== "ESRCH") throw error;
}
}
for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
});
describe("Rust trial lifecycle", () => {
it.each(["nonzero", "timeout"])("replaces old reports and cleans descendants after %s", async (failure) => {
const root = fixture();
const pidFile = join(root, "descendant.pid");
const heartbeat = join(root, "heartbeat");
const command = childCommand(`
const {spawn} = require('node:child_process');
const descendant = spawn(process.execPath, ['-e', ${JSON.stringify(`
const fs = require('node:fs');
process.on('SIGTERM', () => {});
fs.writeFileSync(${JSON.stringify(pidFile)}, String(process.pid));
setInterval(() => fs.appendFileSync(${JSON.stringify(heartbeat)}, '.'), 10);
`)}], {stdio:'ignore'});
const ready = setInterval(() => {
if (!fs.existsSync(${JSON.stringify(pidFile)})) return;
clearInterval(ready);
${failure === "nonzero" ? "process.exit(7);" : "process.on('SIGTERM', () => {}); setInterval(() => {}, 1000);"}
}, 5);
`);
const started = Date.now();
const code = await runRust({
root,
packages: ["ide-text"],
command,
timeoutMs: failure === "timeout" ? 500 : 3000,
cleanupGraceMs: 100,
});
expect(Date.now() - started).toBeLessThan(5000);
expect(code).toBe(1);
const current = report(root);
expect(current.sentinel).toBeUndefined();
expect(current.errors.map((entry: { error: string }) => entry.error).join(" ")).toMatch(
failure === "timeout" ? /timed out/ : /exit 7/,
);
expect(Object.keys(current.results[0].metrics)).toHaveLength(TEXT_BENCHMARKS);
expect(current.meta.mode).toBe("execution");
const runRoot = resolve(current.meta.artifactRoot, "..");
expect(readFileSync(join(runRoot, "cargo.stderr.log"), "utf8")).toContain("partial cargo evidence");
expect(JSON.parse(readFileSync(join(runRoot, "run.json"), "utf8")).error).toBeTruthy();
expect(readFileSync(join(root, "target/perf/report-rust.md"), "utf8")).not.toContain("old passing report");
expect(existsSync(pidFile)).toBe(true);
const pid = Number(readFileSync(pidFile, "utf8"));
ownedPids.push(pid);
const before = existsSync(heartbeat) ? readFileSync(heartbeat, "utf8") : "";
// Observe the real child's heartbeat after cleanup; fake timers cannot advance a subprocess.
await new Promise((done) => setTimeout(done, 100));
expect(existsSync(heartbeat) ? readFileSync(heartbeat, "utf8") : "").toBe(before);
});
it("replaces old reports on spawn failure", async () => {
const root = fixture();
expect(
await runRust({ root, packages: ["ide-text"], command: { file: join(root, "missing-cargo"), args: [] } }),
).toBe(1);
expect(report(root).errors[0].error).toMatch(/spawn failed/);
expect(readFileSync(join(root, "target/perf/report-rust.md"), "utf8")).toContain("spawn failed");
});
it.each(["missing", "malformed"])("reports %s artifacts after a successful child", async (kind) => {
const root = fixture();
const command = childCommand(
kind === "malformed"
? `fs.writeFileSync(path.join(process.env.CRITERION_HOME,'text/open_1mb/new/estimates.json'),'{');`
: "",
kind === "missing" ? [] : undefined,
);
expect(await runRust({ root, packages: ["ide-text"], command, timeoutMs: 3000 })).toBe(1);
expect(report(root).errors.length).toBeGreaterThan(0);
expect(readFileSync(join(root, "target/perf/report-rust.md"), "utf8")).not.toContain("old passing report");
if (kind === "malformed") expect(Object.keys(report(root).results[0].metrics)).toHaveLength(TEXT_BENCHMARKS - 1);
});
it("never reuses old or concurrent roots as current execution", async () => {
const root = fixture();
const earlier = recorded(root, "old", ["ide-text"], Date.now() - 60_000);
const concurrent = recorded(root, "other", ["ide-text"], Date.now() - 30_000);
const future = new Date(Date.now() + 60_000);
utimesSync(join(concurrent, "criterion/text/open_1mb/new/estimates.json"), future, future);
expect(await runRust({ root, packages: ["ide-text"], command: childCommand("", []), timeoutMs: 3000 })).toBe(1);
const current = report(root);
expect(current.results[0].metrics).toEqual({});
expect(current.meta.artifactRoot).not.toBe(join(earlier, "criterion"));
expect(current.meta.artifactRoot).not.toBe(join(concurrent, "criterion"));
expect(current.errors[0].error).toMatch(/missing selected/);
});
it("inspects selected scope and original dates without claiming a new execution", async () => {
const root = fixture();
const runRoot = recorded(root, "selected", ["ide-text", "ide-search"], Date.now() - 60_000);
recorded(root, "unselected-newer", ["ide-heap"], Date.now() - 30_000);
expect(await runRust({ root, packages: ["ide-text"], noRun: true })).toBe(0);
const current = report(root);
expect(current.meta.mode).toBe("inspection");
expect(current.meta.artifactRoot).toBe(join(runRoot, "criterion"));
expect(current.meta.artifactStartedAt).toBe(JSON.parse(readFileSync(join(runRoot, "run.json"), "utf8")).startedAt);
expect(current.artifacts).toHaveLength(2 * TEXT_BENCHMARKS);
expect(
current.artifacts.every((file: { modifiedAt: string }) => Date.parse(file.modifiedAt) < Date.now() - 10_000),
).toBe(true);
expect(Object.keys(current.results[0].metrics)).toHaveLength(TEXT_BENCHMARKS);
});
it("keeps legacy inspection useful and reports artifact dates", async () => {
const root = fixture();
const date = new Date(Date.now() - 120_000);
artifacts(join(root, "target/criterion"), ["ide-text"], date);
expect(await runRust({ root, packages: ["ide-text"], noRun: true })).toBe(0);
const current = report(root);
expect(current.meta.source).toBe("legacy inspection");
expect(current.artifacts[0].modifiedAt).toBe(date.toISOString());
});
it.each(["scope", "future", "running", "failed"])("rejects invalid recorded inspection: %s", async (kind) => {
const root = fixture();
const runRoot = recorded(
root,
"recorded",
kind === "scope" ? ["ide-heap"] : ["ide-text"],
Date.now() - 60_000,
kind === "failed" ? "cargo failed earlier" : undefined,
);
const path = join(runRoot, "run.json");
const manifest = JSON.parse(readFileSync(path, "utf8"));
if (kind === "future") manifest.startedAt = new Date(Date.now() + 60_000).toISOString();
if (kind === "running") delete manifest.finishedAt;
writeFileSync(path, JSON.stringify(manifest));
expect(await runRust({ root, packages: ["ide-text"], noRun: true })).toBe(1);
const error = report(root).errors[0].error;
expect(error).toMatch(
{ scope: /covers selected/, future: /future/, running: /still running/, failed: /failed earlier/ }[kind]!,
);
});
it("rejects artifacts modified after their recorded completion", async () => {
const root = fixture();
const runRoot = recorded(root, "recorded", ["ide-text"], Date.now() - 60_000);
const file = join(runRoot, "criterion/text/open_1mb/new/estimates.json");
const now = new Date();
utimesSync(file, now, now);
expect(await runRust({ root, packages: ["ide-text"], noRun: true })).toBe(1);
expect(report(root).errors[0].error).toMatch(/future Criterion artifact/);
});
});
-253
Переглянути файл
@@ -1,253 +0,0 @@
import {
closeSync,
existsSync,
mkdirSync,
mkdtempSync,
openSync,
readdirSync,
readFileSync,
writeFileSync,
} from "node:fs";
import { basename, join } from "node:path";
import { evaluate, loadBudgets, printReport, type Budgets, type Report, type ScenarioResult } from "./report.ts";
import { inspectRustArtifacts, rustBudgets, rustPaths, selectRustPackages, type RustArtifacts } from "./rust.ts";
import { runCommand } from "./process.ts";
// Includes cold compilation and the complete Criterion workload. Tests inject shorter deadlines.
const CARGO_TIMEOUT_MS = 60 * 60 * 1000;
const CLEANUP_GRACE_MS = 1000;
type CargoOutcome = { error?: string };
type RunManifest = {
id: string;
packages: string[];
startedAt: string;
finishedAt?: string;
error?: string;
cargo?: CargoOutcome;
};
function message(error: unknown): string {
return error instanceof Error ? error.message : String(error);
}
/** Keep cargo output alongside partial Criterion artifacts, including spawn and timeout failures. */
async function runCargo(
command: { file: string; args: string[] },
cwd: string,
env: NodeJS.ProcessEnv,
logs: string,
timeoutMs: number,
graceMs: number,
): Promise<CargoOutcome> {
const stdout = openSync(join(logs, "cargo.stdout.log"), "a");
let stderr: number | undefined;
try {
stderr = openSync(join(logs, "cargo.stderr.log"), "a");
await runCommand(command.file, command.args, {
cwd,
env,
timeoutMs,
graceMs,
label: "cargo bench",
stdio: ["ignore", stdout, stderr],
});
return {};
} catch (error) {
return { error: message(error) };
} finally {
closeSync(stdout);
if (stderr !== undefined) closeSync(stderr);
}
}
function inspectionSource(criterion: string, packages: string[], now: number) {
const runs = join(criterion, "runs");
// Pre-manifest Criterion output is still useful, but is explicitly labelled inspection-only.
if (!existsSync(runs)) return { criterion, kind: "legacy inspection" };
const manifests = readdirSync(runs, { withFileTypes: true })
.filter((entry) => entry.isDirectory())
.map((entry) => {
const root = join(runs, entry.name);
const manifest = JSON.parse(readFileSync(join(root, "run.json"), "utf8")) as RunManifest;
if (
manifest.id !== entry.name ||
!Array.isArray(manifest.packages) ||
!manifest.packages.length ||
manifest.packages.some((p) => typeof p !== "string") ||
!Number.isFinite(Date.parse(manifest.startedAt)) ||
Date.parse(manifest.startedAt) > now + 1000
)
throw new Error(`invalid or future Rust run manifest: ${root}`);
selectRustPackages(manifest.packages);
return { root, manifest };
})
.filter(({ manifest }) => packages.every((p) => manifest.packages.includes(p)))
.sort(
(a, b) =>
Date.parse(b.manifest.startedAt) - Date.parse(a.manifest.startedAt) ||
b.manifest.id.localeCompare(a.manifest.id),
);
const source = manifests[0];
if (!source) throw new Error(`no Rust artifact run covers selected packages: ${packages.join(" ")}`);
const { root, manifest } = source;
if (!manifest.finishedAt) throw new Error(`Rust artifact run is still running or incomplete: ${root}`);
if (
!Number.isFinite(Date.parse(manifest.finishedAt)) ||
Date.parse(manifest.finishedAt) < Date.parse(manifest.startedAt) ||
Date.parse(manifest.finishedAt) > now + 1000
)
throw new Error(`invalid or future Rust run completion date: ${root}`);
return { criterion: join(root, "criterion"), kind: "recorded run inspection", manifest };
}
/** Execute or inspect one Rust trial; infrastructure failures are results, never stale passing reports. */
export async function runRust(options: {
root: string;
packages?: string[];
noRun?: boolean;
saveBaseline?: boolean;
failOnRegression?: boolean;
env?: NodeJS.ProcessEnv;
command?: { file: string; args: string[] };
timeoutMs?: number;
cleanupGraceMs?: number;
}): Promise<number> {
const env = options.env ?? process.env;
const out = join(options.root, "target", "perf");
const baselineFile = join(out, "baseline-rust.json");
const errors: string[] = [];
let packages = options.packages ?? [];
let selectedBudgets: Record<string, number> = {};
let budgets: Budgets | undefined;
let baseline: ScenarioResult[] | null = null;
let evidence: RustArtifacts = { metrics: {}, artifacts: [], errors: [] };
let manifest: RunManifest | undefined;
let runRoot: string | undefined;
let artifactRoot: string | undefined;
let source = options.noRun ? "inspection (no cargo execution)" : "current execution";
const startedAt = new Date().toISOString();
mkdirSync(out, { recursive: true });
writeFileSync(
join(out, "report-rust.json"),
JSON.stringify(
{
meta: { date: startedAt, mode: options.noRun ? "inspection" : "execution", packages },
status: "running",
results: [],
artifacts: [],
},
null,
2,
),
);
writeFileSync(join(out, "report-rust.md"), "# OpenIDEA performance report\n\nRun in progress; no passing verdict.\n");
try {
packages = selectRustPackages(options.packages);
budgets = loadBudgets(join(options.root, "perf", "budgets.json"));
selectedBudgets = rustBudgets(packages, budgets.rust);
const paths = rustPaths(options.root, env);
let artifactStarted: number | undefined;
if (options.noRun) {
const inspection = inspectionSource(paths.criterion, packages, Date.now());
artifactRoot = inspection.criterion;
source = inspection.kind;
manifest = inspection.manifest;
if (manifest?.error) errors.push(`recorded run failed: ${manifest.error}`);
artifactStarted = manifest ? Date.parse(manifest.startedAt) : undefined;
} else {
const timeoutMs = options.timeoutMs ?? Number(env.PERF_RUST_TIMEOUT_MS ?? CARGO_TIMEOUT_MS);
const graceMs = options.cleanupGraceMs ?? CLEANUP_GRACE_MS;
if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647)
throw new Error("invalid PERF_RUST_TIMEOUT_MS");
if (!Number.isFinite(graceMs) || graceMs <= 0 || graceMs > 2_147_483_647)
throw new Error("invalid Rust cleanup deadline");
const runs = join(paths.criterion, "runs");
mkdirSync(runs, { recursive: true });
runRoot = mkdtempSync(join(runs, "run-"));
artifactRoot = join(runRoot, "criterion");
mkdirSync(artifactRoot);
manifest = { id: basename(runRoot), packages, startedAt };
writeFileSync(join(runRoot, "run.json"), JSON.stringify(manifest, null, 2));
console.log(`Rust cargo logs and artifacts: ${runRoot}`);
manifest.cargo = await runCargo(
options.command ?? { file: "cargo", args: ["bench", ...packages.flatMap((p) => ["-p", p]), "--benches"] },
options.root,
{ ...env, CARGO_TARGET_DIR: paths.target, CRITERION_HOME: artifactRoot },
runRoot,
timeoutMs,
graceMs,
);
if (manifest.cargo.error) errors.push(manifest.cargo.error);
artifactStarted = Date.parse(startedAt);
}
evidence = inspectRustArtifacts(
artifactRoot,
packages,
artifactStarted,
options.noRun && manifest?.finishedAt ? Date.parse(manifest.finishedAt) : Date.now(),
);
errors.push(...evidence.errors);
if (existsSync(baselineFile)) baseline = JSON.parse(readFileSync(baselineFile, "utf8")) as ScenarioResult[];
} catch (error) {
errors.push(message(error));
baseline = null;
}
if (runRoot && manifest) {
manifest.finishedAt = new Date().toISOString();
if (errors.length) manifest.error = errors.join("\n");
try {
writeFileSync(join(runRoot, "run.json"), JSON.stringify(manifest, null, 2));
} catch (error) {
errors.push(`Rust run manifest: ${message(error)}`);
}
}
const results: ScenarioResult[] = [
{
id: "rust",
title: "criterion means (µs)",
metrics: evidence.metrics,
...(errors.length ? { error: errors.join("\n") } : {}),
},
];
let report: Report;
try {
report = evaluate(results, selectedBudgets, baseline, {
expected: ["rust"],
enforceBudgets: true,
tolerance: budgets?.regressionTolerance,
floor: budgets?.regressionFloor,
});
} catch (error) {
errors.push(`Rust report evaluation: ${message(error)}`);
results[0]!.error = errors.join("\n");
report = evaluate(results, selectedBudgets, null, { expected: ["rust"], enforceBudgets: true });
}
const meta = {
date: new Date().toISOString(),
unit: "µs (mean)",
packages: packages.join(" "),
mode: options.noRun ? "inspection" : "execution",
source,
artifactRoot: artifactRoot ?? "unavailable",
artifactRunId: manifest?.id ?? "unrecorded",
artifactStartedAt: manifest?.startedAt ?? "unknown (legacy artifacts; see file dates)",
artifactFinishedAt: manifest?.finishedAt ?? "unknown",
};
mkdirSync(out, { recursive: true });
writeFileSync(
join(out, "report-rust.json"),
JSON.stringify(
{ meta, status: report.failures ? "failed" : "complete", ...report, results, artifacts: evidence.artifacts },
null,
2,
),
);
writeFileSync(join(out, "report-rust.md"), printReport(report, meta));
if (errors.length) console.error(errors.join("\n"));
if (options.saveBaseline) {
writeFileSync(baselineFile, JSON.stringify(results, null, 2));
console.log(`Baseline saved to ${baselineFile}`);
}
return report.failures > 0 || (options.failOnRegression && report.regressions > 0) ? 1 : 0;
}
-54
Переглянути файл
@@ -1,54 +0,0 @@
import { describe, expect, test } from "vitest";
import { evidenceJson, metricErrors, summarizeMetrics, summarizeTrials, type Trial } from "./trials.ts";
const measured = (metrics: Record<string, number>, index: number): Trial => {
const errors = metricErrors(metrics, ["ms"]);
return {
phase: "measured",
index,
metrics,
status: errors.length ? "invalid" : "ok",
error: errors.join("; ") || undefined,
};
};
describe("trial integrity", () => {
test.each([NaN, Infinity, -Infinity])("does not hide a nonfinite repetition (%s)", (bad) => {
const trials = [measured({ ms: 1 }, 1), measured({ ms: bad }, 2), measured({ ms: 3 }, 3)];
const summary = summarizeTrials(trials, 3);
expect(summary.metrics.ms).toBeNaN();
expect(summary.error).toContain("measured 2");
expect(summary.counts).toMatchObject({ valid: 2, attempted: 3, planned: 3 });
expect(JSON.parse(evidenceJson(trials))[1].metrics.ms).toBe(String(bad));
});
test("missing required metrics and missing repetitions cannot shrink the denominator", () => {
const trials = [measured({ ms: 1 }, 1), measured({ other: 2 }, 2)];
const summary = summarizeTrials(trials, 3);
expect(summary.metrics.ms).toBeNaN();
expect(summary.error).toContain("ms is missing");
expect(summary.error).toContain("2/3 attempted");
expect(summary.counts).toMatchObject({ valid: 1, attempted: 2, planned: 3 });
});
test("a failed warmup remains fatal alongside good measured runs", () => {
const trials: Trial[] = [
{ phase: "warmup", index: 1, status: "error", metrics: {}, error: "startup failed" },
measured({ ms: 1 }, 1),
];
const summary = summarizeTrials(trials, 1);
expect(summary.metrics.ms).toBe(1);
expect(summary.error).toContain("warmup 1: startup failed");
expect(summary.counts).toMatchObject({ warmupValid: 0, warmupAttempted: 1 });
});
test("retains worst correctness and median timing without filtering invalid entries", () => {
expect(
summarizeMetrics(
[
{ ms: 3, recall: 1 },
{ ms: 1, recall: 0.5 },
],
["recall"],
),
).toEqual({ ms: 1, recall: 0.5 });
expect(summarizeMetrics([{ ms: 1 }, { ms: NaN }]).ms).toBeNaN();
});
});
-57
Переглянути файл
@@ -1,57 +0,0 @@
import { median } from "./stats.ts";
export interface Trial {
phase: "warmup" | "measured";
index: number;
status: "ok" | "invalid" | "error" | "timeout";
metrics: Record<string, number>;
error?: string;
}
export function metricErrors(metrics: Record<string, number>, required: readonly string[]): string[] {
const errors: string[] = [];
if (!Object.keys(metrics).length) errors.push("no metrics produced");
for (const key of new Set([...required, ...Object.keys(metrics)])) {
if (!Number.isFinite(metrics[key])) errors.push(`${key} is missing or nonfinite (${String(metrics[key])})`);
}
return errors;
}
/** Missing or invalid repetitions poison the summary, never shrink its denominator. */
export function summarizeMetrics(samples: readonly Record<string, number>[], minima: readonly string[] = []) {
const keys = [...new Set(samples.flatMap((s) => Object.keys(s)))];
return Object.fromEntries(
keys.map((key) => {
const values = samples.map((s) => s[key]!);
return [key, values.every(Number.isFinite) ? (minima.includes(key) ? Math.min(...values) : median(values)) : NaN];
}),
);
}
export function summarizeTrials(trials: readonly Trial[], planned: number) {
const measured = trials.filter((t) => t.phase === "measured");
const errors = trials.filter((t) => t.status !== "ok").map((t) => `${t.phase} ${t.index}: ${t.error ?? t.status}`);
if (measured.length !== planned) errors.push(`measured trials: ${measured.length}/${planned} attempted`);
return {
metrics: summarizeMetrics(measured.map((t) => t.metrics)),
error: errors.length ? errors.join("; ") : undefined,
counts: {
planned,
attempted: measured.length,
valid: measured.filter((t) => t.status === "ok").length,
warmupAttempted: trials.length - measured.length,
warmupValid: trials.filter((t) => t.phase === "warmup" && t.status === "ok").length,
},
};
}
export const errorMessage = (error: unknown): string =>
error instanceof AggregateError
? `${error.message}: ${error.errors.map(errorMessage).join("; ")}`
: error instanceof Error
? error.message
: String(error);
/** JSON has no nonfinite numbers; retain their identity rather than turning them into null. */
export const evidenceJson = (value: unknown) =>
JSON.stringify(value, (_key, v: unknown) => (typeof v === "number" && !Number.isFinite(v) ? String(v) : v), 2);
+63 -153
Переглянути файл
@@ -12,19 +12,16 @@
* pnpm perf -- --only typing --profile --unminified CPU profile + top functions
*/
import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
import type { Server } from "node:http";
import { join, resolve } from "node:path";
import { parseArgs } from "node:util";
import { gzipSync } from "node:zlib";
import type { Browser, BrowserContext } from "@playwright/test";
import { chromium, type Browser } from "@playwright/test";
import { buildBundle, serveBundle } from "./lib/bundle.ts";
import { Harness, type Metrics, type Scenario } from "./lib/harness.ts";
import { topFunctions, type CpuProfile } from "./lib/profile.ts";
import { installInPage } from "./lib/inpage.ts";
import { countOption } from "./lib/options.ts";
import { evaluate, loadBudgets, printReport, type ScenarioResult } from "./lib/report.ts";
import { closeServer, DeadlineError, launchBrowser, withDeadline, type BrowserSession } from "./lib/lifecycle.ts";
import { errorMessage, evidenceJson, metricErrors, summarizeTrials, type Trial } from "./lib/trials.ts";
import { median } from "./lib/stats.ts";
import { SCENARIOS } from "./scenarios.ts";
const ROOT = resolve(import.meta.dirname, "..");
@@ -54,31 +51,20 @@ if (args.list) {
process.exit(0);
}
const runs = countOption("runs", args.runs!, 1);
const warmup = countOption("warmup", args.warmup!, 0);
const cpu = Number(args.cpu);
if (!args.cpu?.trim() || !Number.isFinite(cpu) || cpu < 1) {
throw new Error("--cpu must be a finite number >= 1");
}
const runs = Math.max(1, Number(args.runs));
const warmup = Math.max(0, Number(args.warmup));
const cpu = Math.max(1, Number(args.cpu));
// Unminified builds keep function names readable in profiles; their bundle size is meaningless.
const DIST = join(OUT, args.unminified ? "dist-unminified" : "dist");
const only = args.only === undefined ? undefined : [...new Set(args.only.split(",").map((s) => s.trim()))];
const known = new Set(SCENARIOS.map((s) => s.id));
if (known.size !== SCENARIOS.length) throw new Error("duplicate scenario ID");
if (only?.some((id) => !known.has(id))) {
throw new Error(`unknown scenario(s): ${only.filter((id) => !known.has(id)).join(", ")} (see --list)`);
}
const only = args.only?.split(",").map((s) => s.trim());
const scenarios = only ? SCENARIOS.filter((s) => only.includes(s.id)) : SCENARIOS;
if (!scenarios.length) throw new Error("empty workload");
const budgets = loadBudgets(join(ROOT, "perf", "budgets.json"));
for (const key of Object.keys(budgets.ui)) {
const id = key.slice(0, key.indexOf("."));
if (id !== "bundle" && !known.has(id)) throw new Error(`budget references unknown scenario: ${key}`);
if (only && scenarios.length !== only.length) {
const known = new Set(SCENARIOS.map((s) => s.id));
throw new Error(`unknown scenario(s): ${only.filter((o) => !known.has(o)).join(", ")} (see --list)`);
}
const expected = [...(args.unminified ? [] : ["bundle"]), ...scenarios.map((s) => s.id)];
async function build() {
await buildBundle(ROOT, DIST, args.unminified ? ["--minify", "false"] : []);
function build() {
buildBundle(ROOT, DIST, args.unminified ? ["--minify", "false"] : []);
}
/** Initial-load JavaScript / CSS from the built index.html (gzip sizes). */
@@ -100,18 +86,12 @@ interface Capture {
}
async function runOnce(browser: Browser, url: string, scenario: Scenario, capture: Capture = {}): Promise<Metrics> {
let context: BrowserContext | undefined;
let finished = false;
const execute = async () => {
context = await browser.newContext({
baseURL: url,
viewport: { width: 1400, height: 900 },
deviceScaleFactor: 1,
});
if (finished) {
await withDeadline(context.close(), 5000, "late context close");
throw new Error("trial already ended");
}
const context = await browser.newContext({
baseURL: url,
viewport: { width: 1400, height: 900 },
deviceScaleFactor: 1,
});
try {
await context.addInitScript(installInPage);
const page = await context.newPage();
const errors: string[] = [];
@@ -142,153 +122,83 @@ async function runOnce(browser: Browser, url: string, scenario: Scenario, captur
}
if (errors.length) throw new Error(`page errors: ${errors.join("; ")}`);
return metrics;
};
try {
return await withDeadline(execute(), 5 * 60_000, `${scenario.id} trial`);
} finally {
finished = true;
if (context) await withDeadline(context.close(), 5000, "context close");
await context.close();
}
}
function aggregate(samples: Metrics[]): Metrics {
const keys = [...new Set(samples.flatMap((s) => Object.keys(s)))];
return Object.fromEntries(keys.map((k) => [k, median(samples.map((s) => s[k]!).filter(Number.isFinite))]));
}
async function main() {
mkdirSync(join(OUT, "traces"), { recursive: true });
mkdirSync(join(OUT, "profiles"), { recursive: true });
const results: ScenarioResult[] = [];
const trials: Record<string, Trial[]> = {};
const counts: Record<string, unknown> = {};
const infrastructure: string[] = [];
const baselineFile = join(OUT, `baseline-${cpu}x.json`);
let baseline: ScenarioResult[] | null = null;
let runtime: BrowserSession | undefined;
let server: Server | undefined;
let browserVersion = "not started";
let completed = false;
const meta = { date: new Date().toISOString(), cpu, runs, warmup, channel: args.channel };
const progress = () => {
writeFileSync(
join(OUT, "report.json"),
evidenceJson({ meta, status: "running", expected, results, trials, counts }),
);
};
progress();
writeFileSync(join(OUT, "report.md"), "# OpenIDEA performance report\n\nRun in progress; no passing verdict.\n");
try {
baseline = existsSync(baselineFile) ? (JSON.parse(readFileSync(baselineFile, "utf8")) as ScenarioResult[]) : null;
if (!args["no-build"]) await build();
if (!existsSync(join(DIST, "index.html"))) throw new Error(`no build in ${DIST}; run without --no-build`);
if (!args.unminified) results.push({ id: "bundle", title: "Initial bundle (gzip)", metrics: bundleMetrics() });
const serving = await serveBundle(DIST);
server = serving.server;
runtime = await launchBrowser({
if (!args["no-build"]) build();
if (!existsSync(join(DIST, "index.html"))) throw new Error(`no build in ${DIST}; run without --no-build`);
const results: ScenarioResult[] = args.unminified
? []
: [{ id: "bundle", title: "Initial bundle (gzip)", metrics: bundleMetrics() }];
const { server, url } = await serveBundle(DIST);
const browser = await chromium
.launch({
channel: args.channel === "chromium" ? undefined : args.channel,
headless: !args.headed,
// Keep rAF / timers at full rate even when the window is not focused.
args: [
"--disable-renderer-backgrounding",
"--disable-background-timer-throttling",
"--disable-backgrounding-occluded-windows",
],
})
.catch((e: Error) => {
throw new Error(
`${e.message}\nInstall the browser with \`pnpm exec playwright install chromium\` or pass --channel msedge|chrome.`,
);
});
browserVersion = runtime.browser.version();
try {
for (const s of scenarios) {
process.stdout.write(`${s.id.padEnd(14)} `);
const attempts: Trial[] = (trials[s.id] = []);
const required = Object.keys(budgets.ui)
.filter((key) => key.startsWith(`${s.id}.`))
.map((key) => key.slice(s.id.length + 1));
for (let i = 0; i < warmup + runs; i++) {
const phase = i < warmup ? "warmup" : "measured";
const index = phase === "warmup" ? i + 1 : i - warmup + 1;
try {
const samples: Metrics[] = [];
try {
for (let i = 0; i < warmup + runs; i++) {
const last = i === warmup + runs - 1;
const metrics = await runOnce(runtime.browser, serving.url, s, {
const m = await runOnce(browser, url, s, {
trace: args.trace && last ? join(OUT, "traces", `${s.id}.json`) : undefined,
profile: args.profile && last ? join(OUT, "profiles", `${s.id}.cpuprofile`) : undefined,
});
const errors = metricErrors(metrics, required);
attempts.push({
phase,
index,
status: errors.length ? "invalid" : "ok",
metrics,
error: errors.join("; ") || undefined,
});
process.stdout.write(errors.length ? "!" : phase === "warmup" ? "w" : ".");
} catch (error) {
attempts.push({
phase,
index,
status: error instanceof DeadlineError ? "timeout" : "error",
metrics: {},
error: errorMessage(error),
});
process.stdout.write(" failed");
progress();
break;
if (i >= warmup) samples.push(m);
process.stdout.write(i < warmup ? "w" : ".");
}
progress();
results.push({ id: s.id, title: s.title, metrics: aggregate(samples) });
console.log();
} catch (e) {
console.log(" failed");
results.push({ id: s.id, title: s.title, metrics: {}, error: e instanceof Error ? e.message : String(e) });
}
const summary = summarizeTrials(attempts, runs);
counts[s.id] = summary.counts;
results.push({ id: s.id, title: s.title, metrics: summary.metrics, error: summary.error });
progress();
console.log();
}
completed = true;
} catch (error) {
infrastructure.push(errorMessage(error));
} finally {
if (runtime) {
try {
await runtime.close();
} catch (error) {
infrastructure.push(`browser cleanup: ${errorMessage(error)}`);
}
}
if (server) {
try {
await closeServer(server);
} catch (error) {
infrastructure.push(`server cleanup: ${errorMessage(error)}`);
}
}
await browser.close();
server.close();
}
const baselineFile = join(OUT, `baseline-${cpu}x.json`);
const baseline = existsSync(baselineFile)
? (JSON.parse(readFileSync(baselineFile, "utf8")) as ScenarioResult[])
: null;
const budgets = loadBudgets(join(ROOT, "perf", "budgets.json"));
const report = evaluate(results, budgets.ui, baseline, {
expected,
enforceBudgets: cpu === 1,
tolerance: budgets.regressionTolerance,
floor: budgets.regressionFloor,
});
for (const error of infrastructure) report.errors.push({ id: "infrastructure", error });
report.failures += infrastructure.length;
const finalMeta = { ...meta, browser: browserVersion };
writeFileSync(
join(OUT, "report.json"),
evidenceJson({
meta: finalMeta,
status: report.failures ? "failed" : "complete",
...report,
expected,
results,
trials,
counts,
infrastructure,
}),
);
const trialTable = [
"",
"## Trials",
"",
"| Scenario | Valid / planned measured | Attempted measured | Valid / attempted warmup |",
"| --- | ---: | ---: | ---: |",
...Object.entries(trials).map(([id, attempts]) => {
const c = summarizeTrials(attempts, runs).counts;
return `| ${id} | ${c.valid}/${c.planned} | ${c.attempted} | ${c.warmupValid}/${c.warmupAttempted} |`;
}),
].join("\n");
writeFileSync(join(OUT, "report.md"), printReport(report, finalMeta) + trialTable + "\n");
if (args["save-baseline"] && completed) {
writeFileSync(baselineFile, evidenceJson(results));
const meta = { date: new Date().toISOString(), cpu, runs, channel: args.channel, browser: browser.version() };
writeFileSync(join(OUT, "report.json"), JSON.stringify({ meta, ...report }, null, 2));
writeFileSync(join(OUT, "report.md"), printReport(report, meta));
if (args["save-baseline"]) {
writeFileSync(baselineFile, JSON.stringify(results, null, 2));
console.log(`Baseline saved to ${baselineFile}`);
}
const failed = report.failures > 0 || (args["fail-on-regression"] && report.regressions > 0);
+63 -9
Переглянути файл
@@ -4,14 +4,19 @@
* and the local baseline.
*
* pnpm perf:rust run benches, then check
* pnpm perf:rust -- --no-run inspect recorded results (no execution)
* pnpm perf:rust -- --no-run check the latest criterion results only
* pnpm perf:rust -- --package ide-text --save-baseline
*/
import { resolve } from "node:path";
import { spawnSync } from "node:child_process";
import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
import { join, resolve } from "node:path";
import { parseArgs } from "node:util";
import { runRust } from "./lib/rustRun.ts";
import { evaluate, loadBudgets, printReport, type ScenarioResult } from "./lib/report.ts";
const ROOT = resolve(import.meta.dirname, "..");
const TARGET = resolve(ROOT, process.env.CARGO_TARGET_DIR ?? "target");
const OUT = join(ROOT, "target", "perf");
const PACKAGES = ["ide-text", "ide-language", "ide-index", "ide-search", "ide-host", "ide-heap"];
const { values: args } = parseArgs({
options: {
@@ -22,10 +27,59 @@ const { values: args } = parseArgs({
},
});
process.exitCode = await runRust({
root: ROOT,
packages: args.package,
noRun: args["no-run"],
saveBaseline: args["save-baseline"],
failOnRegression: args["fail-on-regression"],
const packages = args.package ?? PACKAGES;
const started = Date.now();
if (!args["no-run"]) {
const r = spawnSync("cargo", ["bench", ...packages.flatMap((p) => ["-p", p]), "--benches"], {
cwd: ROOT,
stdio: "inherit",
});
if (r.status !== 0) throw new Error("cargo bench failed");
}
/** Criterion results (`<id>/new/{benchmark,estimates}.json`) → mean in µs. */
function collect(dir: string, out: Record<string, number>) {
if (!existsSync(dir)) return;
for (const entry of readdirSync(dir, { withFileTypes: true })) {
if (!entry.isDirectory() || entry.name === "report") continue;
const sub = join(dir, entry.name);
const bench = join(sub, "new", "benchmark.json");
if (existsSync(bench) && (args["no-run"] || statSync(bench).mtimeMs >= started)) {
const { full_id } = JSON.parse(readFileSync(bench, "utf8")) as { full_id: string };
const est = JSON.parse(readFileSync(join(sub, "new", "estimates.json"), "utf8")) as {
mean: { point_estimate: number };
};
out[full_id] = est.mean.point_estimate / 1000;
}
collect(sub, out);
}
}
const metrics: Record<string, number> = {};
collect(join(TARGET, "criterion"), metrics);
if (Object.keys(metrics).length === 0) throw new Error(`no criterion results under ${join(TARGET, "criterion")}`);
mkdirSync(OUT, { recursive: true });
const budgets = loadBudgets(join(ROOT, "perf", "budgets.json"));
const results: ScenarioResult[] = [{ id: "rust", title: "criterion means (µs)", metrics }];
const baselineFile = join(OUT, "baseline-rust.json");
const baseline = existsSync(baselineFile) ? (JSON.parse(readFileSync(baselineFile, "utf8")) as ScenarioResult[]) : null;
// Only budgets of benches that ran: `--package` may select a subset.
const rustBudgets = Object.fromEntries(
Object.entries(budgets.rust)
.filter(([id]) => args["no-run"] || id in metrics || !args.package)
.map(([id, v]) => [`rust.${id}`, v]),
);
const report = evaluate(results, rustBudgets, baseline, {
enforceBudgets: true,
tolerance: budgets.regressionTolerance,
floor: budgets.regressionFloor,
});
const meta = { date: new Date().toISOString(), unit: "µs (mean)", packages: packages.join(" ") };
writeFileSync(join(OUT, "report-rust.json"), JSON.stringify({ meta, ...report }, null, 2));
writeFileSync(join(OUT, "report-rust.md"), printReport(report, meta));
if (args["save-baseline"]) {
writeFileSync(baselineFile, JSON.stringify(results, null, 2));
console.log(`Baseline saved to ${baselineFile}`);
}
process.exit(report.failures > 0 || (args["fail-on-regression"] && report.regressions > 0) ? 1 : 0);
+9 -5
Переглянути файл
@@ -136,7 +136,7 @@ const completion: Scenario = {
const before = await h.counters();
const narrow = await h.typeMeasured("etOrd", 150);
const work = Harness.delta(before, await h.counters());
const arrows = await h.completionArrowsMeasured(20, 60);
const arrows = await h.pressMeasured(Array(20).fill("ArrowDown"), 60);
await h.page.keyboard.press("Escape");
return {
openMs,
@@ -310,9 +310,13 @@ const scroll: Scenario = {
const smooth = frameSummary(await wheel(160, 120), refresh);
const tbtMs = totalBlockingTime(await h.longTasksSince(t0));
const fling = frameSummary(await wheel(60, 600), refresh);
// Jump far: document-end repositioning.
await h.setCursor(0);
const jumpMs = await h.jumpToEnd();
// Jump far: scrollbar drag / Ctrl+End style repositioning.
const jumpMs = await h.measure(
() => h.page.keyboard.press("Control+End"),
".cm-content",
"export class Repository",
5_000,
);
return {
...smooth,
tbtMs,
@@ -669,7 +673,7 @@ const popups: Scenario = {
);
// Editing the query: Backspace → list re-filtered and painted.
const refresh = await h.refreshMs();
const keyLat = await h.typeMeasured("\b\b\b\b\b\b", 80, "input");
const keyLat = await h.typeMeasured("\b\b\b\b\b\b", 80);
await h.page.keyboard.press("Escape");
await h.page.locator('[role="dialog"]').waitFor({ state: "detached" });
-5
Переглянути файл
@@ -26,11 +26,6 @@ process.stdin.on("data", (chunk) => {
if (buffer.length < end + 4 + length) return;
const request = JSON.parse(buffer.subarray(end + 4, end + 4 + length));
buffer = buffer.subarray(end + 4 + length);
if (mode === "no-initialize" && request.method === "initialize") continue;
if (mode === "bad-header") {
process.stdout.write("Not-a-length: 0\r\n\r\n");
continue;
}
const body = JSON.stringify({
jsonrpc: "2.0",
id: request.id,
-21
Переглянути файл
@@ -58,27 +58,6 @@ test("close waits for graceful EOF cleanup of a tool in its own group", options,
await server.close();
});
test("initialize timeout cleans up the server and its independent tool", options, async () => {
const { home } = await fixture("no-initialize");
// Exercise the actual stdio deadline, rather than replacing the child's clock.
await assert.rejects(Server.start(home, { SMOKE_SERVER_MODE: "no-initialize" }, 500), /initialize timed out/);
const pids = JSON.parse(readFileSync(join(home, "pids.json"), "utf8"));
assertGone(pids.server);
assertGone(pids.tool);
});
test(
"malformed protocol rejects startup and cleans up instead of throwing out of an event callback",
options,
async () => {
const { home, start } = await fixture("bad-header");
await assert.rejects(start(), /bad header/);
const pids = JSON.parse(readFileSync(join(home, "pids.json"), "utf8"));
assertGone(pids.server);
assertGone(pids.tool);
},
);
test("failed initialize still runs graceful cleanup and preserves the error", options, async () => {
const { home, start } = await fixture("reject");
await assert.rejects(start(), { message: "initialize failed" });
+7 -40
Переглянути файл
@@ -1,4 +1,3 @@
/// <reference lib="es2024.promise" />
/**
* `openidea-server --stdio`, spoken to as the desktop app does in remote development:
* JSON-RPC with `Content-Length` framing over the server's stdin / stdout.
@@ -122,21 +121,12 @@ export class Server {
onEvent: (window: string | null, event: unknown) => void = () => {};
private closing: Promise<void> | undefined;
private failure: unknown;
// A plain field, not a parameter property: the evals load this file with Node's type stripping.
private readonly child: ChildProcessWithoutNullStreams;
private constructor(child: ChildProcessWithoutNullStreams) {
this.child = child;
child.stdout.on("data", (chunk: Buffer) => {
try {
this.receive(chunk);
} catch (error) {
this.failure = error;
for (const p of this.pending.values()) p.reject(error);
this.pending.clear();
}
});
child.stdout.on("data", (chunk: Buffer) => this.receive(chunk));
child.stderr.on("data", (chunk: Buffer) => {
// The whole log, when asked for (OPENIDEA_SMOKE_LOG=<file>; OPENIDEA_LOG sets its level).
if (process.env.OPENIDEA_SMOKE_LOG) appendFileSync(process.env.OPENIDEA_SMOKE_LOG, chunk);
@@ -144,7 +134,6 @@ export class Server {
if (this.stderr.length > 200) this.stderr.shift();
});
child.on("error", (error) => {
this.failure = error;
for (const p of this.pending.values()) p.reject(error);
this.pending.clear();
});
@@ -154,14 +143,13 @@ export class Server {
this.pending.clear();
});
child.on("exit", (code) => {
this.failure = new Error(`openidea-server exited (${code}): ${this.log()}`);
for (const p of this.pending.values()) p.reject(new Error(`openidea-server exited (${code}): ${this.log()}`));
this.pending.clear();
});
}
/** Starts a server whose settings, caches and tools live under `home`. */
static async start(home: string, env: Record<string, string> = {}, initializeTimeoutMs = 30_000): Promise<Server> {
static async start(home: string, env: Record<string, string> = {}): Promise<Server> {
const child = spawn(serverBinary(), ["--stdio"], {
env: { ...process.env, OPENIDEA_SERVER_HOME: home, ...env },
stdio: ["pipe", "pipe", "pipe"],
@@ -170,7 +158,7 @@ export class Server {
});
const server = new Server(child);
try {
await server.request("initialize", { version: PROTOCOL_VERSION }, initializeTimeoutMs);
await server.request("initialize", { version: PROTOCOL_VERSION });
return server;
} catch (error) {
await server.close();
@@ -270,33 +258,12 @@ export class Server {
if (errors.size > 1) throw new AggregateError(errors, "Smoke server cleanup failed");
}
private request(method: string, params: unknown, timeoutMs = 5 * 60_000): Promise<unknown> {
if (this.failure) return Promise.reject(this.failure);
if (this.closing) return Promise.reject(new Error("openidea-server is closing"));
private request(method: string, params: unknown): Promise<unknown> {
const id = this.nextId++;
const { promise, resolve, reject } = Promise.withResolvers<unknown>();
const timer = setTimeout(() => {
this.pending.delete(id);
reject(new Error(`${method} timed out after ${timeoutMs} ms`));
}, timeoutMs);
this.pending.set(id, {
resolve: (value) => {
clearTimeout(timer);
resolve(value);
},
reject: (error) => {
clearTimeout(timer);
reject(error);
},
});
try {
return new Promise((resolve, reject) => {
this.pending.set(id, { resolve, reject });
this.send({ jsonrpc: "2.0", id, method, params });
} catch (error) {
clearTimeout(timer);
this.pending.delete(id);
reject(error);
}
return promise;
});
}
private send(message: unknown) {
-11
Переглянути файл
@@ -18,16 +18,6 @@ pub async fn window_group_merge(window: WebviewWindow) -> IdeResult<()> {
groups::persist(window.app_handle()).await
}
/// Adds window `label` to this window's group as a new project tab and selects it. Unlike
/// [`window_group_merge`], unrelated windows keep their own group.
#[desktop_command(trust = always)]
#[tauri::command]
#[specta::specta]
pub async fn window_group_join(window: WebviewWindow, label: String) -> IdeResult<()> {
groups::join(window.app_handle(), window.label(), &label)?;
groups::persist(window.app_handle()).await
}
#[desktop_command(trust = always)]
#[tauri::command]
#[specta::specta]
@@ -96,7 +86,6 @@ ide_command::desktop_domain!(
window_group_close_tabs,
window_group_current,
window_group_detach,
window_group_join,
window_group_merge,
window_group_reorder,
window_group_restore,
+1
Переглянути файл
@@ -105,6 +105,7 @@ fn native_select(app: &AppHandle, group: &Group, to: &WebviewWindow) -> IdeResul
crate::macos::sync_tab_group(members, &anchor, to).map_err(|e| IdeError::internal(e.to_string()))
}
#[cfg(target_os = "macos")]
pub fn join(app: &AppHandle, anchor: &str, new_window: &str) -> IdeResult<()> {
let state = app.state::<WindowsState>();
state.groups.lock().join(anchor, new_window)?;
-1
Переглянути файл
@@ -726,7 +726,6 @@ window_group_close always desktop bin
window_group_close_tabs always desktop bindings sync
window_group_current always desktop bindings sync
window_group_detach always desktop bindings async
window_group_join always desktop bindings async
window_group_merge always desktop bindings async
window_group_reorder always desktop bindings async
window_group_restore always desktop bindings async
-11
Переглянути файл
@@ -1918,11 +1918,6 @@ export const commands = {
windowGroupCloseTabs: (keep: string, labels: string[]) => typedError<null, IdeError>(__TAURI_INVOKE("window_group_close_tabs", { keep, labels })),
windowGroupCurrent: () => typedError<WindowTab[], IdeError>(__TAURI_INVOKE("window_group_current")),
windowGroupDetach: (label: string) => typedError<null, IdeError>(__TAURI_INVOKE("window_group_detach", { label })),
/**
* Adds window `label` to this window's group as a new project tab and selects it. Unlike
* [`window_group_merge`], unrelated windows keep their own group.
*/
windowGroupJoin: (label: string) => typedError<null, IdeError>(__TAURI_INVOKE("window_group_join", { label })),
windowGroupMerge: () => typedError<null, IdeError>(__TAURI_INVOKE("window_group_merge")),
windowGroupReorder: (labels: string[]) => typedError<null, IdeError>(__TAURI_INVOKE("window_group_reorder", { labels })),
windowGroupRestore: () => typedError<null, IdeError>(__TAURI_INVOKE("window_group_restore")),
@@ -3750,12 +3745,6 @@ export type CommitSettings = {
doubleClickOpensDiff?: boolean | null,
/** Team conventions for Generate Commit Message with Agent, added to its prompt. */
agentInstructions?: string,
/** The coding agent Generate Commit Message with Agent uses; empty follows the latest task's agent. */
agent?: string,
/** That agent's model for commit messages; empty keeps the model the agent would use. */
agentModel?: string,
/** That model's thinking level for commit messages; empty keeps the agent's. */
agentEffort?: string,
};
export type Commit_Deserialize = {
-14
Переглянути файл
@@ -66,7 +66,6 @@ function show(view: EditorView): string {
}
const javascript = await languages.find((l) => l.name === "JavaScript")!.load();
const yaml = await languages.find((l) => l.name === "YAML")!.load();
describe("Move Statement", () => {
it("moves a multi-line statement as a whole, never one of its lines", () => {
@@ -204,19 +203,6 @@ describe("paste reformatting", () => {
paste(v, "a();\n b();\n c();");
expect(v.state.doc.toString()).toBe("if {\n a();\n b();\n c();\n}");
});
it("pastes onto a blank line at the previous line's indent when the language has no indent engine", () => {
const doc = "service:\n database:\n query-timeout: 30\n pool:\n validation-query: SELECT 1\n";
const v = make(doc + "|", [yaml, pasteReindentFilter("indentEachLine")]);
paste(v, "query-timeout: 30");
expect(v.state.doc.toString()).toBe(doc + " query-timeout: 30");
});
it("pastes a block onto a blank line at the indent of the nearest non-empty line above", () => {
const v = make("outer:\n key: 1\n\n|\ntrailing: 2", [yaml, pasteReindentFilter("indentBlock")]);
paste(v, "a: 1\n b: 2");
expect(v.state.doc.toString()).toBe("outer:\n key: 1\n\n a: 1\n b: 2\ntrailing: 2");
});
});
describe("closing quotes", () => {
+1 -14
Переглянути файл
@@ -222,15 +222,6 @@ function leadingColumns(text: string, tabSize: number): number {
return col;
}
/** Indentation of the nearest non-empty line above `line` (1-based), for pastes onto a blank line in languages without an indent engine. */
function previousLineIndent(state: EditorState, line: number): number | null {
for (let n = line - 1; n >= 1; n--) {
const prev = state.doc.line(n);
if (/\S/.test(prev.text)) return leadingColumns(prev.text, state.tabSize);
}
return null;
}
/** Reformat on paste › Indent Block: re-indents a pasted block to the caret's indentation. */
export function indentPastedText(
text: string,
@@ -286,11 +277,7 @@ export function pasteReindentFilter(mode: "indentBlock" | "indentEachLine") {
let targetCol = leadingColumns(atIndent ? before : line.text, tabSize);
let prefix = "";
if (atIndent) {
let proper = getIndentation(start, line.from);
if (!targetCol && !proper) {
const above = previousLineIndent(start, line.number);
if (above) proper = above;
}
const proper = getIndentation(start, line.from);
if (proper !== null && proper !== targetCol) {
targetCol = proper;
prefix = indentString(start, proper);
-67
Переглянути файл
@@ -274,73 +274,6 @@ describe("pickAgent", () => {
});
});
describe("pickAgent with an agent chosen for commit messages", () => {
const effort: AgentConfigOption = {
id: "effort",
name: "Effort",
description: null,
category: "thought_level",
current: "high",
values: ["low", "high"].map((value) => ({ value, name: value, description: null })),
via: "option",
};
const claude = { ...provider("claude", true, [modelOption("smart")]), thoughtLevels: { fast: [effort] } };
const tasks = [
task("a", "claude", { updatedMs: 1, config: [modelOption("smart")] }),
task("b", "codex", { updatedMs: 5 }),
];
const prefer = (agent: string, model = "", level = "") => ({ agent, agentModel: model, agentEffort: level });
it("uses that agent over the latest task's, on the model of its own latest task", () => {
expect(pickAgent(tasks, [claude, provider("codex")], draft("codex"), prefer("claude"))).toEqual({
provider: "claude",
config: [{ id: "model", value: "smart" }],
});
});
it("runs the chosen model at the chosen effort", () => {
expect(pickAgent(tasks, [claude, provider("codex")], draft("codex"), prefer("claude", "fast", "low"))).toEqual({
provider: "claude",
config: [
{ id: "model", value: "fast" },
{ id: "effort", value: "low" },
],
});
});
it("reads the models from the agent's refreshed catalog", () => {
const catalog = {
config: [{ ...modelOption("smart"), values: [{ value: "mini", name: "mini", description: null }] }],
thoughtLevels: { mini: [effort] },
};
expect(
pickAgent([], [claude], draft("claude"), prefer("claude", "mini", "low"), new Map([["claude", catalog]])),
).toEqual({
provider: "claude",
config: [
{ id: "model", value: "mini" },
{ id: "effort", value: "low" },
],
});
});
it("keeps the agent's model and effort for values it doesn't offer", () => {
expect(pickAgent([], [claude], draft("claude"), prefer("claude", "gone", "low"))).toEqual({
provider: "claude",
config: [{ id: "model", value: "smart" }],
});
});
it("follows the latest task when the chosen agent isn't installed", () => {
expect(
pickAgent(tasks, [provider("claude", false), provider("codex")], draft("codex"), prefer("claude", "fast")),
).toEqual({
provider: "codex",
config: [],
});
});
});
describe("generateCommitMessage", () => {
const changes = { revision: 3, roots: ["/p"], patch: PATCH };
const notified = () => backend.notify.mock.calls.map(([n]) => n as { level: string; title: string; body?: string });
+9 -62
Переглянути файл
@@ -3,14 +3,7 @@
* changes about to be committed and writes their message. It runs as a short task that
* is deleted once the message is in the commit field.
*/
import type {
AgentConfigChoice,
AgentConfigOption,
AgentEntry,
AgentModelCatalog,
AgentProvider,
AgentTask,
} from "@/bindings";
import type { AgentConfigChoice, AgentConfigOption, AgentEntry, AgentProvider, AgentTask } from "@/bindings";
import { executeAction } from "@/platform/actions";
import { tx } from "@/platform/i18n";
import { call, commands } from "@/platform/ipc";
@@ -146,74 +139,28 @@ export function askingChoices(options: readonly AgentConfigOption[]): AgentConfi
const choicesFor = (options: readonly AgentConfigOption[]) => [...modelChoice(options), ...askingChoices(options)];
/** Settings › Version Control › Commit: the agent, model and thinking level to generate with; empty follows the agent. */
export interface CommitAgentPreference {
agent: string;
agentModel: string;
agentEffort: string;
}
type ModelCatalog = Pick<AgentModelCatalog, "config" | "thoughtLevels">;
/**
* The agent that wrote the code: the one of the project's latest task, on the model it
* ran with. Without a task, the one the New Task page has selected. An agent chosen in
* the settings replaces it, on the model and thinking level chosen there when it offers them.
* ran with. Without a task, the one the New Task page has selected.
*/
export function pickAgent(
tasks: Iterable<AgentTask>,
providers: readonly AgentProvider[],
draft: Draft,
preference?: CommitAgentPreference,
catalogs?: ReadonlyMap<string, ModelCatalog>,
): CommitAgent | null {
const installed = providers.filter((p) => p.installed);
const chosen = preference?.agent ? installed.find((p) => p.id === preference.agent) : undefined;
const candidates = chosen ? [chosen] : installed;
const latest = [...tasks]
.filter((t) => t.status !== "archived" && candidates.some((p) => p.id === t.provider))
.filter((t) => t.status !== "archived" && installed.some((p) => p.id === t.provider))
.sort((a, b) => (b.updatedMs ?? 0) - (a.updatedMs ?? 0))[0];
const provider = latest
? installed.find((p) => p.id === latest.provider)!
: (chosen ?? installed.find((p) => p.id === draft.provider) ?? installed[0]);
if (latest) return { provider: latest.provider, config: choicesFor(latest.config) };
const provider = installed.find((p) => p.id === draft.provider) ?? installed[0];
if (!provider) return null;
const options = latest
? latest.config
: provider.id === draft.provider
? draftConfig(provider, draft)
: provider.config;
if (!chosen || !preference || (!preference.agentModel && !preference.agentEffort)) {
return { provider: provider.id, config: choicesFor(options) };
}
return {
provider: provider.id,
config: [...preferredModel(options, provider, preference, catalogs?.get(provider.id)), ...askingChoices(options)],
config: choicesFor(provider.id === draft.provider ? draftConfig(provider, draft) : provider.config),
};
}
/** The model and thinking level of `preference` that the agent offers, else the ones it would run with. */
function preferredModel(
options: readonly AgentConfigOption[],
provider: AgentProvider,
preference: CommitAgentPreference,
catalog: ModelCatalog | undefined,
): AgentConfigChoice[] {
const offered = (catalog?.config ?? provider.config).find((o) => o.category === "model");
const fallback = modelChoice(options);
const model =
offered && preference.agentModel && offered.values.some((v) => v.value === preference.agentModel)
? { id: offered.id, value: preference.agentModel }
: fallback[0];
if (!model) return [];
const levels = (catalog?.thoughtLevels ?? provider.thoughtLevels)?.[model.value] ?? [];
const level = levels.find((o) => o.category === "thought_level");
const effort =
level && preference.agentEffort && level.values.some((v) => v.value === preference.agentEffort)
? [{ id: level.id, value: preference.agentEffort }]
: [];
return [model, ...effort];
}
/** Resolves when the task's turn ends; rejects when it can't produce an answer. */
function turnEnd(task: string): Promise<void> {
return new Promise((resolve, reject) => {
@@ -296,9 +243,8 @@ async function generate(): Promise<void> {
notify({ level: "info", title: "No changes to describe", body: "Include changes in the commit first." });
return;
}
const { commit } = workflowSettings().vcs;
const { tasks, providers, draft, modelCatalogs } = useAgents.getState();
const agent = pickAgent(tasks.values(), providers, draft, commit, modelCatalogs);
const { tasks, providers, draft } = useAgents.getState();
const agent = pickAgent(tasks.values(), providers, draft);
if (!agent) {
notify({
level: "warning",
@@ -309,6 +255,7 @@ async function generate(): Promise<void> {
return;
}
const { commit } = workflowSettings().vcs;
const subjects = await recentSubjects(changes.roots[0]);
const prompt = commitMessagePrompt(
changes.patch,
+10 -29
Переглянути файл
@@ -173,8 +173,6 @@ export function SessionComposer({
return task.config.map((o) => (o === model ? pickerModel : o));
}, [task.config, model, candidateModels]);
const [sending, setSending] = useState(false);
const configChange = useRef<{ loadingModel: boolean } | null>(null);
const [configuring, setConfiguring] = useState<typeof configChange.current>(null);
const [mcpOpenRequest, setMcpOpenRequest] = useState(0);
const [assetFocus, setAssetFocus] = useState(0);
const agentCommands = useAgentCommands(task.provider, task.id, task.commands);
@@ -193,7 +191,7 @@ export function SessionComposer({
task.status === "running" &&
(composer.images.length === 0 || !!task.capabilities.images);
const send = (now: boolean) => {
if (!canSend(composer) || sending || configChange.current || task.status === "archived") return;
if (!canSend(composer) || sending || task.status === "archived") return;
setSending(true);
sendMessage(task.id, now && (whileRunning !== "steer" || steers))
.catch((e: unknown) =>
@@ -205,30 +203,14 @@ export function SessionComposer({
)
.finally(() => setSending(false));
};
const setOption = (id: string, value: string) => {
const changingModel = id === model?.id;
const loadingModel = changingModel && !model.values.some((v) => v.value === value);
const pendingModel = model?.current != null && model.current !== task.model;
const change = loadingModel || (changingModel && configChange.current) || pendingModel ? { loadingModel } : null;
if (change) {
configChange.current = change;
setConfiguring(change);
}
void setTaskConfig(task.id, id, value)
.catch((e: unknown) =>
notifications().notify({
level: "error",
title: "Couldn't change the setting",
body: String(e),
}),
)
.finally(() => {
if (change && configChange.current === change) {
configChange.current = null;
setConfiguring(null);
}
});
};
const setOption = (id: string, value: string) =>
void setTaskConfig(task.id, id, value).catch((e: unknown) =>
notifications().notify({
level: "error",
title: "Couldn't change the setting",
body: String(e),
}),
);
const openMcp = () => setMcpOpenRequest((n) => n + 1);
const shown = useEditorShown();
const effortAnnouncement = useEffortFocus(focusRoot, shown && task.status !== "archived", task.config, setOption);
@@ -287,7 +269,6 @@ export function SessionComposer({
canRefreshModels
? {
refreshing: requestingModels || (catalog?.refreshing ?? false),
loadingSettings: configuring?.loadingModel,
retryAtMs: catalog?.retryAtMs ?? null,
error: requestingModels ? null : (catalog?.error ?? null),
onOpen: () => void refreshTaskModels(task.id, false),
@@ -322,7 +303,7 @@ export function SessionComposer({
label={busy ? "Queue" : "Send"}
pending={sending}
variant={busy ? "secondary" : "primary"}
disabled={!canSend(composer) || sending || configuring !== null || task.status === "archived"}
disabled={!canSend(composer) || sending || task.status === "archived"}
onClick={() => send(false)}
/>
</>
+1 -35
Переглянути файл
@@ -8,7 +8,6 @@ const workspaceUpdate = vi.fn();
const projectCurrent = vi.fn();
const windowOpenProject = vi.fn();
const windowOpenFiles = vi.fn();
const windowGroupJoin = vi.fn();
const windowTakeLaunch = vi.fn();
const windowCompleteLaunch = vi.fn();
const wslResolve = vi.fn();
@@ -45,7 +44,6 @@ vi.mock("@/platform/ipc", async (orig) => {
projectCurrent: () => projectCurrent(),
windowOpenProject: (...a: unknown[]) => windowOpenProject(...a),
windowOpenFiles: (...a: unknown[]) => windowOpenFiles(...a),
windowGroupJoin: (...a: unknown[]) => windowGroupJoin(...a),
windowTakeLaunch: () => windowTakeLaunch(),
windowCompleteLaunch: () => windowCompleteLaunch(),
wslResolve: (p: string) => wslResolve(p),
@@ -113,8 +111,7 @@ beforeEach(() => {
workspaceAttach.mockReset();
workspaceUpdate.mockReset();
projectCurrent.mockReset();
for (const f of [windowOpenProject, windowOpenFiles, windowGroupJoin, windowTakeLaunch, wslResolve]) f.mockReset();
windowGroupJoin.mockResolvedValue(ok(null));
for (const f of [windowOpenProject, windowOpenFiles, windowTakeLaunch, wslResolve]) f.mockReset();
windowTakeLaunch.mockResolvedValue(null);
windowCompleteLaunch.mockReset().mockResolvedValue(ok(null));
wslResolve.mockResolvedValue(null);
@@ -697,37 +694,6 @@ describe("Attach", () => {
});
});
describe("Project tabs", () => {
it("opens the project in its own window and joins that window into this window's group", async () => {
useProject.setState(projectState("/p/a"));
vi.mocked(ask).mockResolvedValueOnce({ button: "tab", checked: false });
windowOpenProject.mockResolvedValue(ok({ kind: "opened", label: "main-2" }));
await openProjectWithPolicy("/p/b", ["/p/b/file.txt"]);
expect(confirmProjectTrust).toHaveBeenCalledWith("/p/b", "local");
expect(windowOpenProject).toHaveBeenCalledWith("/p/b", true, ["/p/b/file.txt"]);
expect(windowGroupJoin).toHaveBeenCalledWith("main-2");
// The new window opens its own files, and this window keeps its project.
expect(opened).toEqual([]);
expect(openProject).not.toHaveBeenCalled();
expect(confirmLeaveProject).not.toHaveBeenCalled();
});
it("groups the window that already has the project", async () => {
useProject.setState(projectState("/p/a"));
vi.mocked(ask).mockResolvedValueOnce({ button: "tab", checked: false });
windowOpenProject.mockResolvedValue(ok({ kind: "focused", label: "main-3" }));
await openProjectWithPolicy("/p/b");
expect(windowGroupJoin).toHaveBeenCalledWith("main-3");
});
it("reports a window it could not group", async () => {
useProject.setState(projectState("/p/a"));
vi.mocked(ask).mockResolvedValueOnce({ button: "tab", checked: false });
windowOpenProject.mockResolvedValue(ok({ kind: "opened", label: "main-2" }));
windowGroupJoin.mockRejectedValueOnce(new Error("Window closed"));
await openProjectWithPolicy("/p/b");
expect(notify).toHaveBeenCalledWith(expect.objectContaining({ level: "error", body: "Window closed" }));
});
});
it("removes the first workspace member while retaining the workspace state root", async () => {
const project = {
root: "/workspace",
-37
Переглянути файл
@@ -26,7 +26,6 @@ import { connectRemote, isRemoteWindow } from "@/platform/remote";
import { holdSplash } from "@/platform/splash";
import { editorService, maybeEditorService, notifications } from "@/workbench/contributions";
import { chooseProjectWindow } from "@/workbench/projectWindow";
import { openTabColorPicker } from "@/workbench/TabColorPicker";
import { cycleWindowTab, useWindowGroup } from "@/platform/windowGroups";
import { editorSwitching } from "@/editor/api";
import { showWorkspaceDialog } from "./WorkspaceDialog";
@@ -186,10 +185,6 @@ export async function openProjectWithPolicy(path: string, files: readonly string
await attachProject(path, files);
return;
}
if (mode === "tab") {
await openProjectTab(path, files);
return;
}
try {
// A window that already has the project is focused instead.
const outcome = await call(commands.windowOpenProject(path, false, [...files]));
@@ -220,19 +215,6 @@ async function attachProject(path: string, files: readonly string[] = []): Promi
}
}
/** Opens `path` as a new project tab of this window: a window of its own, joined into this window's group. */
async function openProjectTab(path: string, files: readonly string[]): Promise<void> {
try {
// `new_window` always answers with the window holding the project, focused or just created;
// either way that window becomes this window's tab.
const outcome = await openProjectWindow(path, true, files);
if (outcome.kind === "current") return;
await call(commands.windowGroupJoin(outcome.label));
} catch (e) {
openFailed(path, e);
}
}
/** LightEdit: opens the current file's folder as a project ("Open project in" applies) and the file there. */
export async function openLightEditFileAsProject(): Promise<void> {
if (!useProject.getState().lightEdit) return;
@@ -436,25 +418,6 @@ export function windowActions(): Action[] {
if (label) await call(commands.windowGroupDetach(label));
},
},
{
id: "window.setTabColor",
title: "Change Project Color…",
category: t("app.category.window"),
when: "windowGrouped",
run: ({ arg }) => {
const tabs = useWindowGroup.getState().tabs;
const label = typeof arg === "string" ? arg : tabs.find((tab) => tab.current)?.label;
const tab = tabs.find((t) => t.label === label);
if (!tab?.root) return;
const rect = document.querySelector(`[data-project-tab="${CSS.escape(tab.label)}"]`)?.getBoundingClientRect();
openTabColorPicker({
root: tab.root,
name: tab.name,
x: rect ? rect.left : window.innerWidth / 2 - 110,
y: rect ? rect.bottom : 64,
});
},
},
{
id: "window.selectTab",
title: "Select Project Tab",
+6 -43
Переглянути файл
@@ -14,24 +14,6 @@
flex: 1;
min-height: 0;
}
.results {
display: flex;
min-height: 0;
height: 100%;
}
.toolbar {
flex: none;
display: flex;
flex-direction: column;
gap: var(--space-1);
padding: var(--space-1);
border-inline-end: 1px solid var(--border);
overflow-y: auto;
}
.tree {
flex: 1;
min-width: 0;
}
.tabs {
min-width: 0;
border: 0;
@@ -56,21 +38,10 @@
flex: none;
color: var(--fg-muted);
}
.fileLocation {
display: flex;
gap: var(--space-1-5);
min-width: 0;
overflow: hidden;
}
.fileName {
flex: none;
max-inline-size: 100%;
overflow: hidden;
text-overflow: ellipsis;
color: var(--fg-strong);
}
.fileError {
padding-block: var(--space-0-5);
text-decoration-line: underline;
text-decoration-style: wavy;
text-decoration-color: var(--danger);
@@ -80,25 +51,18 @@
.selectedText {
color: var(--fg-strong);
}
.directory {
min-width: 0;
overflow: hidden;
text-overflow: ellipsis;
.muted {
flex: none;
color: var(--fg-subtle);
}
.count {
flex: none;
max-inline-size: 50%;
overflow: hidden;
text-overflow: ellipsis;
color: var(--fg-subtle);
margin-left: 4px;
}
.source {
min-width: 0;
max-inline-size: 25%;
margin-inline-start: auto;
overflow: hidden;
text-overflow: ellipsis;
flex: none;
margin-left: auto;
padding-right: 8px;
color: var(--fg-faint);
}
.message {
@@ -113,7 +77,6 @@
.position {
flex: none;
color: var(--fg-subtle);
font-variant-numeric: tabular-nums;
}
.sev-error {
flex: none;
+19 -42
Переглянути файл
@@ -22,7 +22,6 @@ import {
SplitHandle,
SplitPanel,
Tabs,
Toolbar,
Tree,
fileIconName,
showContextMenu,
@@ -214,11 +213,11 @@ function useCurrentPath(): string | null {
return currentProblemsPath(text, useSyncExternalStore(subscribeActiveInput, activeInput));
}
function ProblemsToolbar() {
export function ProblemsHeaderActions() {
const show = useProblemsView((s) => s.show);
const toggle = useProblemsView((s) => s.toggle);
return (
<Toolbar aria-label="Problems actions" orientation="vertical" className={styles.toolbar}>
<>
<IconButton icon="arrow-up" action="navigate.prevOccurrence" size="small" />
<IconButton icon="arrow-down" action="navigate.nextOccurrence" size="small" />
<IconButton icon="error" title="Show Errors" size="small" pressed={show.error} onClick={() => toggle("error")} />
@@ -236,7 +235,7 @@ function ProblemsToolbar() {
pressed={show.info}
onClick={() => toggle("info")}
/>
</Toolbar>
</>
);
}
@@ -338,44 +337,33 @@ export function ProblemsView() {
const renderNode = (n: Node, state: TreeRowState) => {
if (n.kind === "file") {
const name = basename(n.path);
const directory = relativeDir(root, n.path);
const c = countSeverities(n.items);
const counts = [plural(c.error, "error"), plural(c.warning, "warning"), plural(c.info + c.hint, "info")]
.filter(Boolean)
.join(", ");
const parts = [plural(c.error, "error"), plural(c.warning, "warning"), plural(c.info + c.hint, "info")].filter(
Boolean,
);
return (
<span className={styles.row}>
<Icon name={fileIconName(name, n.path)} size={16} className={styles.fileIcon} />
<span className={styles.fileLocation}>
<span
className={clsx(styles.fileName, c.error > 0 && styles.fileError, state.selected && styles.selectedText)}
title={name}
>
{name}
</span>
{directory && (
<span className={styles.directory} title={directory}>
{directory}
</span>
)}
</span>
<span className={styles.count} title={counts}>
{counts}
<Icon name={fileIconName(basename(n.path), n.path)} size={16} className={styles.fileIcon} />
<span
className={clsx(styles.fileName, c.error > 0 && styles.fileError, state.selected && styles.selectedText)}
>
{basename(n.path)}
</span>
<span className={styles.muted}>{relativeDir(root, n.path)}</span>
<span className={styles.count}>{parts.join(", ")}</span>
</span>
);
}
const d = n.d;
const source = d.source && (d.code ? `${d.source}(${d.code})` : d.source);
return (
<span className={styles.row} title={d.message}>
<Icon name={SEVERITY_ICON[d.severity]} size={14} className={styles[`sev-${d.severity}`]} />
<span className={clsx(styles.message, d.deprecated && styles.deprecated)}>{d.message.split("\n")[0]}</span>
<span className={styles.position}>:{d.range.start.line + 1}</span>
{source && (
<span className={styles.source} title={source}>
{source}
{d.source && (
<span className={styles.source}>
{d.source}
{d.code ? `(${d.code})` : ""}
</span>
)}
</span>
@@ -390,10 +378,9 @@ export function ProblemsView() {
);
const selected = target(lead);
const treeView = (
const list = (
<Tree<Node>
aria-label="Problems"
className={styles.tree}
handleRef={tree}
roots={roots}
getKey={(n) => n.key}
@@ -441,11 +428,7 @@ export function ProblemsView() {
run: () => copy(n),
},
...inspectionMenu(n.kind === "diag" ? diagInspection(map, n.path, n.d) : null),
...menuGroupItems("problems", {
paths: [t.path],
line: t.d.range.start.line,
column: t.d.range.start.col,
}),
...menuGroupItems("problems", { paths: [t.path], line: t.d.range.start.line, column: t.d.range.start.col }),
]);
}}
activateExpandable={false}
@@ -453,12 +436,6 @@ export function ProblemsView() {
empty={empty}
/>
);
const list = (
<div className={styles.results}>
<ProblemsToolbar />
{treeView}
</div>
);
return (
<div className={styles.view}>
+2 -1
Переглянути файл
@@ -15,7 +15,7 @@ import {
import { getContext } from "@/platform/context";
import { clearProblems, installProblemsEvents, problemsReport, useProblems } from "./problemsStore";
import { installProblemDecorations } from "./decorations";
import { ProblemsTabs, ProblemsView, useProblemsHeaderMenu } from "./ProblemsView";
import { ProblemsHeaderActions, ProblemsTabs, ProblemsView, useProblemsHeaderMenu } from "./ProblemsView";
import { UsagesTabs, UsagesView, useUsagesHeaderMenu } from "./UsagesView";
import { UsagesPopup } from "./UsagesPopup";
import { findUsages, rerunActiveUsages, resetUsages, showUsageResults, showUsagesPopup } from "./usages";
@@ -79,6 +79,7 @@ export function activate(): () => void {
order: 30,
component: ProblemsView,
headerContent: ProblemsTabs,
headerActions: ProblemsHeaderActions,
headerMenu: useProblemsHeaderMenu,
useBadge: useErrorBadge,
}),
+4 -12
Переглянути файл
@@ -21,7 +21,7 @@
height: 100%;
display: flex;
align-items: center;
gap: var(--space-1);
gap: 5px;
border-radius: var(--radius-row);
}
@@ -41,16 +41,9 @@
overflow: hidden;
text-overflow: ellipsis;
}
.labelGroup {
display: flex;
align-items: center;
gap: var(--space-1);
min-width: 0;
overflow: hidden;
}
.labelGroup .label {
.rootName {
flex: none;
max-inline-size: 100%;
max-width: 60%;
}
.rootLabel {
color: var(--fg-strong);
@@ -67,7 +60,6 @@
text-decoration-line: line-through;
}
.error {
padding-block: var(--space-0-5);
text-decoration-line: underline;
text-decoration-style: wavy;
text-decoration-color: var(--danger);
@@ -96,7 +88,7 @@
}
.detail {
min-width: 0;
margin-inline-start: var(--space-1);
margin-left: 4px;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
+21 -30
Переглянути файл
@@ -338,29 +338,26 @@ const Row = memo(function Row({
/>
) : (
<>
<span className={styles.labelGroup}>
<HighlightedText
className={clsx(
styles.label,
// Project and module roots use semibold labels.
node.root && !node.icon && styles.rootLabel,
moduleFolder && styles.moduleLabel,
faded && !deco.color && styles.excluded,
file?.deprecated && styles.deprecated,
deco.error && styles.error,
)}
style={deco.color ? { color: deco.color } : undefined}
text={node.label}
indices={matches}
tone="accent"
/>
{deco.suffix && <DecorationSuffix segments={deco.suffix} color={deco.suffixColor} />}
{detail && (
<span className={styles.detail} title={detail}>
{detail}
</span>
<HighlightedText
className={clsx(
styles.label,
node.root && styles.rootName,
// Only the project itself is bold (IDEA); contributed roots like Scratches are not.
node.root && !node.icon && styles.rootLabel,
// Maven / Gradle module folders are bold too, as in IDEA.
moduleFolder && styles.moduleLabel,
faded && !deco.color && styles.excluded,
// IDEA strikes out deprecated classes.
file?.deprecated && styles.deprecated,
deco.error && styles.error,
)}
</span>
style={deco.color ? { color: deco.color } : undefined}
text={node.label}
indices={matches}
tone="accent"
/>
{deco.suffix && <DecorationSuffix segments={deco.suffix} color={deco.suffixColor} />}
{detail && <span className={styles.detail}>{detail}</span>}
{deco.badge && <span className={styles.badge}>{deco.badge}</span>}
</>
)}
@@ -424,14 +421,8 @@ const MemberRow = memo(function MemberRow({
onPointerDown={(e) => onPointerDown(node, e)}
>
<SymbolBadge kind={badgeKind(item.kind)} className={styles.icon} />
<span className={styles.labelGroup}>
<HighlightedText className={styles.label} text={item.name} indices={matches} tone="accent" />
{item.detail && (
<span className={styles.detail} title={item.detail}>
{item.detail}
</span>
)}
</span>
<HighlightedText className={styles.label} text={item.name} indices={matches} tone="accent" />
{item.detail && <span className={styles.detail}>{item.detail}</span>}
</span>
);
});
-46
Переглянути файл
@@ -668,52 +668,6 @@ describe("temporary configurations", () => {
await saveTemporary(app.id).catch(() => undefined);
expect(useRun.getState().temporary).toEqual([]);
});
it("reuse the detected configuration of the same Maven goal instead of adding a temporary one", () => {
const detected = cfg({ id: "maven:package", kind: "maven", name: "mvn package", args: ["package"] });
useRun.setState({ configs: [detected] });
const goal = cfg({
id: "maven:goal:pom.xml:package",
kind: "maven",
name: "demo [package]",
args: ["package"],
detected: false,
});
expect(adoptTemporary(goal)).toBe(detected);
expect(useRun.getState().temporary).toEqual([]);
expect(useRun.getState().selectedId).toBe(detected.id);
});
it("reuse a Maven goal configuration with the same command line, but not across goals, flags, builds or tools", () => {
const detected = cfg({ id: "maven:package", kind: "maven", name: "mvn package", args: ["package"] });
useRun.setState({ configs: [detected] });
const goal = (over: Partial<RunConfig>): RunConfig =>
cfg({ id: "maven:goal:pom.xml:package", kind: "maven", args: ["package"], detected: false, ...over });
expect(adoptTemporary(goal({}))).toBe(detected);
expect(
adoptTemporary(goal({ id: "maven:goal:pom.xml:package.skipTests", args: ["package", "-DskipTests"] })).id,
).toBe("maven:goal:pom.xml:package.skipTests");
expect(adoptTemporary(goal({ id: "maven:goal:pom.xml:clean", args: ["clean"] })).id).toBe(
"maven:goal:pom.xml:clean",
);
expect(adoptTemporary(goal({ id: "maven:goal:core/pom.xml:package", args: ["package"], cwd: "core" })).id).toBe(
"maven:goal:core/pom.xml:package",
);
expect(adoptTemporary(goal({ id: "gradle:task:...:package", kind: "gradle", command: "gradle" })).id).toBe(
"gradle:task:...:package",
);
const { configs, temporary } = useRun.getState();
expect(temporary).toHaveLength(4);
expect(configs.filter((c) => !temporary.includes(c.id))).toEqual([detected]);
});
it("reuse the detected configuration of the same Gradle tasks", () => {
const detected = cfg({ id: "gradle:test", kind: "gradle", name: "gradle test", args: ["test"], isTest: true });
useRun.setState({ configs: [detected] });
const task = cfg({ id: "gradle:task:...:test", kind: "gradle", args: ["test"], detected: false });
expect(adoptTemporary(task)).toBe(detected);
expect(useRun.getState().temporary).toEqual([]);
});
});
describe("jvmMainCandidates", () => {
+1 -14
Переглянути файл
@@ -447,17 +447,6 @@ function sameApplication(a: RunConfig, b: RunConfig): boolean {
return main !== null && main === parseJavaArgs(b.args).mainClass && (a.module ?? a.cwd) === (b.module ?? b.cwd);
}
/**
* IDEA's `isConfigurationFromContext` for a Maven / Gradle goal: the same command line run by the
* same build tool in the same build directory, whatever the configuration is named (#4436). The
* existing configuration is run as is, so reuse must not drop option flags.
*/
function sameBuildGoal(a: RunConfig, b: RunConfig): boolean {
if ((a.kind !== "maven" && a.kind !== "gradle") || a.kind !== b.kind) return false;
if (a.command !== b.command || (a.cwd ?? "") !== (b.cwd ?? "")) return false;
return a.args.length > 0 && a.args.length === b.args.length && a.args.every((arg, i) => arg === b.args[i]);
}
/**
* Selects the configuration for a gutter / context run: a saved or detected
* configuration with the same id is reused, otherwise `config` becomes a
@@ -468,9 +457,7 @@ export function adoptTemporary(config: RunConfig): RunConfig {
// IDEA's `findExistingConfiguration`: a configuration the user keeps for this context wins.
const existing =
state.configs.find((c) => c.id === config.id) ??
state.configs.find(
(c) => !state.temporary.includes(c.id) && (sameApplication(c, config) || sameBuildGoal(c, config)),
);
state.configs.find((c) => !state.temporary.includes(c.id) && sameApplication(c, config));
if (existing && !state.temporary.includes(config.id)) {
selectConfig(existing.id);
return existing;
-118
Переглянути файл
@@ -14,7 +14,6 @@ import { Button, Icon, IconButton, Input, Select, type SelectOption, T } from "@
import { choosePath } from "@/platform/choosePath";
import { Row, SettingSelect } from "../components/Form";
import { useSetting } from "../components/context";
import type { AgentModelCatalog, AgentProvider } from "@/bindings";
import type { PageSpec } from "./spec";
import { BoundToggle, Grid, Indented, RadioRow, TableEditor, ToggleNumber } from "./workflowControls";
import styles from "./Workflow.module.css";
@@ -379,117 +378,6 @@ function MessageLimits() {
);
}
const AUTOMATIC = "";
/** The installed coding agents, as the agents feature reports them; empty where agents can't run. */
function useInstalledAgents(): AgentProvider[] {
const [agents, setAgents] = useState<AgentProvider[]>([]);
useEffect(() => {
if (!isTauri()) return;
let live = true;
call(commands.agentProviders())
.then((all) => live && setAgents(all.filter((p) => p.installed)))
.catch(() => {});
return () => {
live = false;
};
}, []);
return agents;
}
type ModelCatalog = Pick<AgentModelCatalog, "config" | "thoughtLevels">;
/** The models `agent` offers, from its catalog; asks the agent for it once when it hasn't reported one. */
function useModelCatalog(agent: AgentProvider | undefined): ModelCatalog | undefined {
const [catalog, setCatalog] = useState<{ provider: string } & ModelCatalog>();
const id = agent?.id;
useEffect(() => {
if (!id) return;
let live = true;
let timer: ReturnType<typeof setTimeout> | undefined;
let polls = 0;
const load = () =>
call(commands.agentRefreshModels(id, false, null))
.then((c) => {
if (!live) return;
setCatalog(c);
if (c.refreshing && ++polls < CATALOG_POLLS) timer = setTimeout(load, CATALOG_POLL_MS);
})
.catch(() => {});
void load();
return () => {
live = false;
clearTimeout(timer);
};
}, [id]);
if (!agent) return undefined;
const fresh = catalog?.provider === agent.id && catalog.config.some((o) => o.category === "model");
return fresh ? catalog : { config: agent.config, thoughtLevels: agent.thoughtLevels ?? {} };
}
const CATALOG_POLL_MS = 1_500;
const CATALOG_POLLS = 40;
/** `values` as options after `automatic`, keeping a saved value the agent no longer lists. */
function choiceOptions(
automatic: string,
values: readonly { value: string; name: string }[],
saved: string,
): SelectOption<string>[] {
const options = [{ value: AUTOMATIC, label: automatic }, ...values.map((v) => ({ value: v.value, label: v.name }))];
return saved && !values.some((v) => v.value === saved) ? [...options, { value: saved, label: saved }] : options;
}
function CommitAgentRows() {
const agents = useInstalledAgents();
const [agent, setAgent] = useSetting<string>("vcs.commit.agent");
const [model, setModel] = useSetting<string>("vcs.commit.agentModel");
const [effort, setEffort] = useSetting<string>("vcs.commit.agentEffort");
const catalog = useModelCatalog(agents.find((p) => p.id === agent));
const models = catalog?.config.find((o) => o.category === "model");
const shown = model || models?.current;
const levels = (shown ? catalog?.thoughtLevels[shown] : undefined)?.find((o) => o.category === "thought_level");
const agentOptions = choiceOptions(
tx("Automatic (the agent of the latest task)"),
agents.map((p) => ({ value: p.id, name: p.name })),
agent,
);
const pick = (next: string) => {
if (next === agent) return;
setAgent(next);
setModel(AUTOMATIC);
setEffort(AUTOMATIC);
};
return (
<>
<Row label="Agent" hint="Commit messages are short: a fast model with low effort is usually enough.">
<Select value={agent} options={agentOptions} onChange={pick} aria-label={tx("Agent")} />
</Row>
<Row label="Model" disabled={!agent}>
<Select
value={model}
options={choiceOptions(tx("The agent's current model"), models?.values ?? [], model)}
onChange={(next) => {
setModel(next);
setEffort(AUTOMATIC);
}}
disabled={!agent}
aria-label={tx("Model")}
/>
</Row>
<Row label="Effort" disabled={!agent}>
<Select
value={effort}
options={choiceOptions(tx("The agent's default"), levels?.values ?? [], effort)}
onChange={setEffort}
disabled={!agent}
aria-label={tx("Effort")}
/>
</Row>
</>
);
}
function AgentInstructionsRow() {
const [value, set] = useSetting<string>("vcs.commit.agentInstructions");
const id = useId();
@@ -643,12 +531,6 @@ export const VCS_PAGES: PageSpec[] = [
{
title: "Commit Message Generation",
options: [
{
kind: "custom",
label: "Agent",
keywords: ["agent", "ai", "model", "effort", "thinking", "reasoning", "generate commit message"],
component: CommitAgentRows,
},
{
kind: "custom",
label: "Instructions for Generate Commit Message with Agent",
+17 -38
Переглянути файл
@@ -1,27 +1,18 @@
.view {
height: 100%;
display: flex;
min-height: 0;
}
.toolbar {
flex: none;
display: flex;
flex-direction: column;
gap: var(--space-1);
padding: var(--space-1);
border-inline-end: 1px solid var(--border);
overflow-y: auto;
}
.content {
flex: 1;
min-width: 0;
min-height: 0;
display: flex;
flex-direction: column;
}
.body {
flex: 1;
min-height: 0;
display: flex;
flex-direction: column;
}
.body > * {
flex: 1;
min-height: 0;
}
.tabs {
min-width: 0;
@@ -46,12 +37,13 @@
display: flex;
align-items: center;
gap: var(--space-1-5);
padding: var(--space-1) var(--space-2);
height: 32px;
padding: 0 8px;
border-bottom: 1px solid var(--border);
}
.scopeSelect {
flex: 0 1 224px;
min-width: 0;
min-width: 200px;
max-width: 360px;
}
.row {
display: flex;
@@ -65,17 +57,7 @@
flex: none;
color: var(--fg-muted);
}
.fileLocation {
display: flex;
gap: var(--space-1-5);
min-width: 0;
overflow: hidden;
}
.fileName {
flex: none;
max-inline-size: 100%;
overflow: hidden;
text-overflow: ellipsis;
color: var(--fg-emphasis);
}
.selectedText {
@@ -84,31 +66,28 @@
.muted {
flex: none;
color: var(--fg-subtle);
}
.directory {
min-width: 0;
overflow: hidden;
text-overflow: ellipsis;
color: var(--fg-subtle);
font-size: var(--fs-small);
}
.count {
flex: none;
color: var(--fg-subtle);
font-size: var(--fs-small);
margin-left: 4px;
}
.position {
flex: none;
min-inline-size: 3ch;
text-align: end;
font-variant-numeric: tabular-nums;
font-family: var(--font-mono);
font-size: var(--fs-small);
color: var(--fg-subtle);
}
.text {
min-width: 0;
overflow: hidden;
text-overflow: ellipsis;
font-style: italic;
}
.keyword {
font-weight: 600;
font-style: normal;
}
.loading {
display: flex;
+2 -2
Переглянути файл
@@ -29,7 +29,7 @@ describe("TodoView", () => {
render(<TodoView />);
expect(screen.getByText("a.ts")).toBeInTheDocument();
expect(screen.getByText("2 items")).toBeInTheDocument();
expect(screen.getByText("5")).toHaveAttribute("title", "(5, 4)");
expect(screen.getByText("(5, 4)")).toBeInTheDocument();
expect(screen.getByText(": wire it")).toBeInTheDocument();
act(() => useTodoView.getState().toggleKeyword("FIXME"));
expect(screen.getByText("1 item")).toBeInTheDocument();
@@ -135,7 +135,7 @@ describe("TodoView", () => {
render(<TodoView />);
// Select the file group so the preview has an item (trees select on mousedown).
fireEvent.mouseDown(screen.getByText("a.ts").closest("[role=treeitem]")!);
await screen.findByText("5");
await screen.findByText("(5, 4)");
// No editing switch: the preview is simply an editor, like IntelliJ's.
expect(screen.queryByLabelText("Allow editing")).toBeNull();
// No document attacher in tests: the editable pane degrades to its error
+18 -32
Переглянути файл
@@ -19,7 +19,6 @@ import {
SplitPanel,
Spinner,
Tabs,
Toolbar,
Tree,
fileIconName,
type MenuItem,
@@ -292,16 +291,14 @@ function ItemText({ item }: { item: TodoItem }) {
const kwLen = item.keyword.length;
const color = colorFor(item.keyword);
return (
<span className={styles.text}>
<strong className={styles.keyword} style={{ color }}>
{item.text.slice(0, kwLen)}
</strong>
<span className={styles.text} style={{ color }}>
<strong className={styles.keyword}>{item.text.slice(0, kwLen)}</strong>
{item.text.slice(kwLen)}
</span>
);
}
function TodoToolbar() {
export function TodoHeaderActions() {
const settings = useTodoSettings();
const hidden = useTodoView((s) => s.hidden);
const toggleKeyword = useTodoView((s) => s.toggleKeyword);
@@ -319,7 +316,7 @@ function TodoToolbar() {
})),
];
return (
<Toolbar aria-label="TODO actions" orientation="vertical" className={styles.toolbar}>
<>
<IconButton icon="arrow-up" action="navigate.prevOccurrence" size="small" />
<IconButton icon="arrow-down" action="navigate.nextOccurrence" size="small" />
<IconButton
@@ -338,7 +335,7 @@ function TodoToolbar() {
onClick={() => updateTodoSettings({ caseSensitive: !settings.caseSensitive })}
/>
<IconButton icon="refresh" size="small" title="Refresh" disabled={scanning} onClick={() => void scanProject()} />
</Toolbar>
</>
);
}
@@ -424,20 +421,11 @@ export function TodoView() {
const renderNode = (n: Node, state: TreeRowState) => {
if (n.kind === "file") {
const name = basename(n.group.path);
const directory = relativeDir(root, n.group.path);
return (
<span className={styles.row}>
<Icon name={fileIconName(name)} size={16} className={styles.fileIcon} />
<span className={styles.fileLocation}>
<span className={clsx(styles.fileName, state.selected && styles.selectedText)} title={name}>
{name}
</span>
{directory && (
<span className={styles.directory} title={directory}>
{directory}
</span>
)}
</span>
<span className={clsx(styles.fileName, state.selected && styles.selectedText)}>{name}</span>
<span className={styles.muted}>{relativeDir(root, n.group.path)}</span>
<span className={styles.count}>
{n.group.items.length === 1 ? tx`${n.group.items.length} item` : tx`${n.group.items.length} items`}
</span>
@@ -446,8 +434,8 @@ export function TodoView() {
}
return (
<span className={styles.row} title={n.item.text}>
<span className={styles.position} title={`(${n.item.line + 1}, ${n.item.col + 1})`}>
{n.item.line + 1}
<span className={styles.position}>
({n.item.line + 1}, {n.item.col + 1})
</span>
<ItemText item={n.item} />
</span>
@@ -481,20 +469,18 @@ export function TodoView() {
return (
<div className={styles.view}>
<TodoToolbar />
<div className={styles.content}>
{tab === "project" && limitHit && (
<div className={styles.banner}>
<T>Too many matches; showing the first 10 000.</T>
</div>
)}
{tab === "scope" && <ScopeBar />}
{tab === "changes" && <ChangelistBar />}
{tab === "project" && limitHit && (
<div className={styles.banner}>
<T>Too many matches; showing the first 10 000.</T>
</div>
)}
{tab === "scope" && <ScopeBar />}
{tab === "changes" && <ChangelistBar />}
<div className={styles.body}>
<SplitGroup
orientation="horizontal"
id="todo-preview-split"
storageKey={showPreview ? "openidea.todo.previewSplit" : undefined}
className={styles.body}
>
<SplitPanel id="items" minSize={160} className={styles.panel}>
<Tree<Node>
@@ -533,7 +519,7 @@ export function TodoView() {
{showPreview && (
<>
<SplitHandle />
<SplitPanel id="preview" minSize={160} defaultSize="50%" className={styles.panel}>
<SplitPanel id="preview" minSize={160} defaultSize="45%" className={styles.panel}>
<TodoPreview node={lead} />
</SplitPanel>
</>
+2 -1
Переглянути файл
@@ -4,7 +4,7 @@ import { registerEditorContribution } from "@/editor/api";
import { registerToolWindow, toolWindowService } from "@/workbench/contributions";
import { hasIcon } from "@/ui";
import { activateSettingsPages } from "./settingsPages";
import { TodoTabs, TodoView, useTodoBadge, useTodoHeaderMenu, useTodoView } from "./TodoView";
import { TodoHeaderActions, TodoTabs, TodoView, useTodoBadge, useTodoHeaderMenu, useTodoView } from "./TodoView";
import { todoEditorExtension } from "./highlight";
import { installTodoIndex, scanProject, syncTodoSettingsFromStorage } from "./store";
@@ -21,6 +21,7 @@ export function activate(): () => void {
order: 40,
component: TodoView,
headerContent: TodoTabs,
headerActions: TodoHeaderActions,
headerMenu: useTodoHeaderMenu,
useBadge: useTodoBadge,
}),
+5 -22
Переглянути файл
@@ -25,7 +25,7 @@ import {
T,
} from "@/ui";
import type { PopupAnchor } from "@/ui/Popup";
import { buildBranchRows, preferredBranchRow, withExpanded, type BranchRow, type PopupAction } from "./branches";
import { buildBranchRows, withExpanded, type BranchRow, type PopupAction } from "./branches";
import { branchPresentation, extensionPopupActions, useBranchWidgetExtensions } from "./branchWidgetExtensions";
import { branchMenu, commonBranchMenu, inRepo, tagMenu } from "./branchMenu";
import { loadFavoriteBranches, recentBranches, toggleFavoriteBranch, useFavoriteBranches } from "./branchOps";
@@ -33,7 +33,6 @@ import { inProgress, operationTitle, type InProgress } from "./operations";
import {
buildMultiRepoRows,
currentRepoFor,
preferredRepoRow,
repoHeadLabel,
widgetShowsRepo,
type RepoEntry,
@@ -46,22 +45,6 @@ import type { SyncDirection } from "./syncCommits";
import styles from "./BranchWidget.module.css";
import { tx } from "@/platform/i18n";
/** `active` until the user moves: a new filter selects the row IDEA prefers for it. */
const PREFERRED = -1;
function pickActive<R>(
rows: readonly R[],
active: number,
isSection: (r: R) => boolean,
preferred: () => number,
): number {
if (active === PREFERRED) {
const i = preferred();
if (i >= 0) return i;
} else if (rows[active] && !isSection(rows[active]!)) return active;
return firstSelectable(rows, isSection);
}
export const useBranchesPopup = create<{ open: boolean }>(() => ({ open: false }));
export const showBranchesPopup = () => useBranchesPopup.setState({ open: true });
@@ -463,7 +446,7 @@ function BranchesPanel({ onClose, actions: baseActions, root, fallback, onBack }
[branches, recent, query, actions, favorites, tags, options, expanded],
);
const isSection = (r: BranchRow) => r.type === "section";
const activeIndex = pickActive(rows, active, isSection, () => preferredBranchRow(rows, query));
const activeIndex = rows[active] && !isSection(rows[active]!) ? active : firstSelectable(rows, isSection);
const scoped = (items: MenuItem[]) => (root ? inRepo(root, items) : items);
const closeAll = () => {
@@ -545,7 +528,7 @@ function BranchesPanel({ onClose, actions: baseActions, root, fallback, onBack }
value={query}
onChange={(v) => {
setQuery(v);
setActive(PREFERRED);
setActive(0);
}}
placeholder={label}
aria-label={label}
@@ -700,7 +683,7 @@ function MultiRepoPanel({ onClose, actions: popupActions }: { onClose: () => voi
[repos, all, query, actions, expanded, favorites, current, recent, tags, options],
);
const isSection = (r: RepoRow) => r.type === "section";
const activeIndex = pickActive(rows, active, isSection, () => preferredRepoRow(rows, query));
const activeIndex = rows[active] && !isSection(rows[active]!) ? active : firstSelectable(rows, isSection);
const closeAll = () => {
setMenuFor(null);
@@ -795,7 +778,7 @@ function MultiRepoPanel({ onClose, actions: popupActions }: { onClose: () => voi
value={query}
onChange={(v) => {
setQuery(v);
setActive(PREFERRED);
setActive(0);
}}
placeholder="Search for branches, actions, repositories"
aria-label="Search for branches, actions, repositories"
+8 -12
Переглянути файл
@@ -168,7 +168,7 @@
.list {
flex: 1;
min-height: 0;
overflow: hidden auto;
overflow: auto;
outline: none;
/* Rows coming and going while scrolling relay out the list alone, not the workbench. */
contain: strict;
@@ -181,8 +181,8 @@
height: 26px;
display: flex;
align-items: center;
gap: min(var(--space-2), 2%);
padding: 0 min(var(--space-2), 2%);
gap: var(--space-2);
padding: 0 8px;
white-space: nowrap;
cursor: default;
font-size: var(--fs-ui);
@@ -199,18 +199,18 @@
background: var(--bg-app);
}
.columnCell {
flex: 0 1 auto;
min-width: 0;
flex: none;
overflow: hidden;
text-overflow: ellipsis;
/* Keep the first glyph clear of the divider on this column's left edge.
box-sizing: border-box keeps the width and boundary position unchanged. */
padding-inline-start: min(var(--space-2), 2%);
padding-inline-start: var(--space-2);
/* Anchor for the full-height column resize strip (IDEA's invisible divider). */
position: relative;
}
.columnHeading {
position: relative;
padding-inline-end: 6px;
cursor: grab;
touch-action: none;
}
@@ -314,7 +314,7 @@
--log-row-bg: var(--bg-tree-selected);
}
.colSubject {
flex: 1 0 min(220px, 50%);
flex: 1;
min-width: 0;
display: flex;
align-items: center;
@@ -365,12 +365,9 @@
}
.graph {
flex: none;
/* Leave room for the subject when the graph has many lanes: the lanes past it are cut off, not squeezed. */
max-width: calc(100% - min(120px, 50%));
fill: none;
stroke-width: 1.6;
overflow: visible;
clip-path: inset(-50% 0);
}
.refs {
flex: 0 1 auto;
@@ -763,8 +760,7 @@
}
.colRepository {
flex: 0 1 100px;
min-width: 0;
flex: 0 0 100px;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
-39
Переглянути файл
@@ -7,7 +7,6 @@ import {
buildBranchTree,
filterBranchTree,
isFavoriteBranch,
preferredBranchRow,
pushRecent,
type BranchRow,
type BranchTreeNode,
@@ -185,44 +184,6 @@ describe("buildBranchRows", () => {
});
});
describe("preferredBranchRow", () => {
const ticket = [
b("feature/lwp/KXSC-3599"),
b("feature/lwp/KXSC-5994"),
b("feature/lwp/KXSC-5997"),
b("KXSC-5990"),
b("origin/feature/lwp/KXSC-5994", { remote: true }),
];
const picked = (list: Branch[], query: string, acts = actions) => {
const rows = buildBranchRows(list, [], query, acts);
const i = preferredBranchRow(rows, query);
return i < 0 ? null : summary(rows)[i]!.trim();
};
it("selects the best-matching local branch, not the group above it", () => {
expect(picked(ticket, "599")).toBe("local:KXSC-5994");
});
it("prefers a match at the start of the name's last segment", () => {
expect(picked([b("fix-main-build"), b("release/main")], "main")).toBe("local:main");
expect(picked([b("feature/ordering"), b("hotfix/order")], "order")).toBe("local:order");
});
it("falls back to remote branches, then tags", () => {
expect(picked([b("main"), b("origin/feature/x", { remote: true })], "feature")).toBe("remote:x");
expect(
summary(buildBranchRows([b("main")], [], "v1", [], null, ["v1.0"]))[
preferredBranchRow(buildBranchRows([b("main")], [], "v1", [], null, ["v1.0"]), "v1")
],
).toBe(" tag:v1.0");
});
it("selects a matching action first, and nothing without a query", () => {
expect(picked(branches, "push")).toBe("> Push…");
expect(preferredBranchRow(buildBranchRows(branches, [], "", actions), "")).toBe(-1);
});
});
describe("branchNamePrefixes", () => {
it("lists local branch folders shallowest first, once each, without remote ones", () => {
const prefixes = branchNamePrefixes([
-11
Переглянути файл
@@ -5,7 +5,6 @@ import {
buildMultiRepoRows,
commonBranches,
currentRepoFor,
preferredRepoRow,
repoColorIndex,
repoHeadLabel,
widgetShowsRepo,
@@ -164,16 +163,6 @@ describe("buildMultiRepoRows", () => {
]);
});
it("selects the best match while filtering: repositories, then common branches, then one repository's", () => {
const picked = (query: string) => {
const rows = buildMultiRepoRows({ ...input, expanded: new Map(), query });
return summary(rows)[preferredRepoRow(rows, query)]?.trim();
};
expect(picked("dev")).toBe("dev (current)");
expect(picked("deps")).toBe("repo ology-dependencies [dev] c2");
expect(picked("fix")).toBe("ology-gateway:gw-fix");
});
it("filters repositories and branches, expands every group and lists each repository's own matches", () => {
expect(summary(buildMultiRepoRows({ ...input, expanded: new Map(), query: "dev" }))).toEqual([
"v Common Local Branches",
-57
Переглянути файл
@@ -208,63 +208,6 @@ export function recentLocal(local: readonly Branch[], recent: readonly string[])
export const sortTags = (tags: readonly string[]) =>
[...tags].sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
/**
* How well `name` matches `query`: at the start of its last segment, at a word start, matching the
* segment to its end, then nearer the segment's start.
*/
function matchDegree(name: string, query: string): number {
const match = wordMatch(name, query);
const at = match?.[0];
if (at === undefined) return -Infinity;
const segment = name.lastIndexOf("/") + 1;
const wordStart = at === 0 || /[\s_\-./\\:]/.test(name[at - 1]!);
const toEnd = match!.at(-1) === name.length - 1;
return (at === segment ? 4 : 0) + (wordStart ? 2 : 0) + (toEnd ? 1 : 0) - Math.abs(at - segment) / (name.length + 1);
}
/**
* The row to select while filtering, as IDEA's branches popup does: the best match of the
* lowest-ranked kind that has one (matching actions, then local branches, remote ones, tags).
* -1 without a query or a candidate.
*/
export function preferredMatch<R>(
rows: readonly R[],
query: string,
candidate: (row: R) => { rank: number; name: string } | null,
): number {
const q = query.trim();
if (!q) return -1;
let best = -1;
let bestRank = Infinity;
let bestDegree = -Infinity;
rows.forEach((row, i) => {
const c = candidate(row);
if (!c || c.rank > bestRank) return;
const degree = matchDegree(c.name, q);
if (c.rank < bestRank || degree > bestDegree) {
best = i;
bestRank = c.rank;
bestDegree = degree;
}
});
return best;
}
const GROUP_RANK: Record<BranchGroup, number> = { recent: 1, local: 2, remote: 3 };
/** `preferredMatch` for the branches popup of one repository. */
export function preferredBranchRow(rows: readonly BranchRow[], query: string): number {
return preferredMatch(rows, query, (r) =>
r.type === "action"
? { rank: 0, name: tx(r.action.label) }
: r.type === "branch"
? { rank: GROUP_RANK[r.group], name: r.branch.name }
: r.type === "tag"
? { rank: 4, name: r.tag }
: null,
);
}
/**
* Rows for the Branches popup: actions (separated by group), then the collapsible
* Recent (recently checked-out local branches other than the current one), Local,
-2
Переглянути файл
@@ -390,8 +390,6 @@ export const viewerTheme = EditorView.theme(
"&.cm-merge-a .cm-changedLineGutter, .cm-deletedLineGutter": { background: "var(--gutter-deleted)" },
"&.cm-merge-b .cm-changedLineGutter": { background: "var(--gutter-modified)" },
".cm-collapsedLines": {
WebkitUserSelect: "none",
userSelect: "none",
padding: "2px 10px",
background: "var(--bg-elev)",
color: "var(--fg-subtle)",
+13 -2
Переглянути файл
@@ -26,7 +26,15 @@ const HIDDEN_COLUMN_OPTION: Record<string, keyof LogOptions> = {
repository: "showRepository",
};
export function ColumnHeaders({ columns, options }: { columns: LogColumn[]; options: LogOptions }) {
export function ColumnHeaders({
columns,
options,
minWidth,
}: {
columns: LogColumn[];
options: LogOptions;
minWidth: number;
}) {
const [drag, setDrag] = useState<ColumnDrag | null>(null);
const ids = columnSequence(options.columnOrder, columns);
const cancel = useCallback(() => setDrag(null), []);
@@ -39,7 +47,10 @@ export function ColumnHeaders({ columns, options }: { columns: LogColumn[]; opti
};
const visibleIds = ids.filter((id) => id === SUBJECT_COLUMN.id || columns.some((column) => column.id === id));
return (
<div className={clsx(styles.row, styles.columnHeader, options.showColumnDividers && styles.showDividers)}>
<div
className={clsx(styles.row, styles.columnHeader, options.showColumnDividers && styles.showDividers)}
style={{ minWidth }}
>
{options.showRepository && useVcs.getState().roots.length > 1 && (
<span className={styles.colRepository}>{tx("Repository")}</span>
)}
+12 -3
Переглянути файл
@@ -43,7 +43,7 @@ import { currentRepo, currentRepoRoot, useVcs } from "../store";
import { ColumnHeaders } from "./ColumnHeaders";
import { CommitSignature } from "./CommitMessage";
import { CommitRow } from "./CommitRow";
import { ROW, type LogColumn, type RowEvents } from "./shared";
import { LANE, ROW, type LogColumn, type RowEvents } from "./shared";
const remoteNameSets = new WeakMap<readonly string[], ReadonlySet<string>>();
@@ -197,6 +197,15 @@ export function CommitList() {
),
};
}, [hoverColor, linear, displayedGraph, headKeys]);
const minWidth = useMemo(
() =>
rows.reduce((width, row) => Math.max(width, row.width * LANE), 100) +
columns.reduce(
(width, column) => width + (opts.columnWidths[column.id] ?? column.width ?? 120),
opts.showRepository && useVcs.getState().roots.length > 1 ? 220 : 120,
),
[rows, columns, opts.columnWidths, opts.showRepository],
);
const filterBranches = useGitLog((s) => s.filters.branches);
const currentBranch = useVcs((s) => s.branch?.head ?? null);
// Nothing to tell apart when the log is filtered to the current branch.
@@ -572,11 +581,11 @@ export function CommitList() {
);
}}
>
{opts.showColumnHeaders && <ColumnHeaders columns={columns} options={opts} />}
{opts.showColumnHeaders && <ColumnHeaders columns={columns} options={opts} minWidth={minWidth} />}
{!commits.length && !loading && finished && (
<div className={styles.message}>{headCommit ? tx("No commits match the filters") : tx("No commits yet")}</div>
)}
<div style={{ height: virtualizer.getTotalSize(), position: "relative" }}>
<div style={{ height: virtualizer.getTotalSize(), position: "relative", minWidth }}>
{items.map((v) => {
const c = commits[v.index];
if (!c)
+1 -2
Переглянути файл
@@ -39,7 +39,6 @@ export function GraphCell({
interactive?: boolean;
}) {
const cy = ROW / 2;
const width = row.width * LANE;
const draw = (s: GraphSegment, i: number, up: boolean) => {
const fromX = x(s.fromX ?? s.from);
const toX = x(s.toX ?? s.to);
@@ -113,7 +112,7 @@ export function GraphCell({
return (
<svg
className={styles.graph}
width={width}
width={row.width * LANE}
height={ROW}
aria-label={tx("Commit graph")}
onMouseLeave={() => onHover?.(null)}
-21
Переглянути файл
@@ -7,7 +7,6 @@ import {
actionRows,
defaultFolderOpen,
isFavoriteBranch,
preferredMatch,
prefixTreeRows,
recentLocal,
sortLocal,
@@ -347,23 +346,3 @@ export function buildMultiRepoRows({
}
return rows;
}
/** `preferredMatch` for the branches popup of several repositories: actions, repositories, common branches, then one repository's. */
export function preferredRepoRow(rows: readonly RepoRow[], query: string): number {
return preferredMatch(rows, query, (r) => {
switch (r.type) {
case "action":
return { rank: 0, name: tx(r.action.label) };
case "repo":
return { rank: 1, name: r.repo.name };
case "common":
return { rank: r.branch.remote ? 3 : 2, name: r.branch.name };
case "branch":
return { rank: r.group === "remote" ? 5 : 4, name: r.branch.name };
case "tag":
return { rank: 6, name: r.tag };
default:
return null;
}
});
}
+1 -6
Переглянути файл
@@ -225,12 +225,7 @@ function GroupBoundary({
function ProjectRow({ m, active }: { m: RecentMatch; active: boolean }) {
return (
<>
<ProjectBadge
name={m.project.name}
path={m.project.path}
className={styles.badge}
missing={!!m.project.missing}
/>
<ProjectBadge name={m.project.name} className={styles.badge} missing={!!m.project.missing} />
<span className={styles.text} title={unavailableTitle(m.project)}>
<span className={styles.top}>
<HighlightedText
+1 -6
Переглянути файл
@@ -258,12 +258,7 @@ function ProjectRow({
showContextMenu(e, recentMenu(m.project));
}}
>
<ProjectBadge
name={m.project.name}
path={m.project.path}
className={styles.projectBadge}
missing={!!m.project.missing}
/>
<ProjectBadge name={m.project.name} className={styles.projectBadge} missing={!!m.project.missing} />
<span className={styles.projectText}>
<HighlightedText
className={clsx(styles.projectName, m.project.missing && styles.unavailable)}
+6 -18
Переглянути файл
@@ -1,5 +1,5 @@
import { writeClipboardText } from "@/platform/clipboard";
import { useMemo, useState, useSyncExternalStore, type KeyboardEvent, type MouseEvent, type ReactNode } from "react";
import { useMemo, useState, type KeyboardEvent, type MouseEvent, type ReactNode } from "react";
import clsx from "clsx";
import { call, commands, type RecentProject, type RecentProjectGroup } from "@/platform/ipc";
import { revealInFileManager, showInFileManagerLabel } from "@/platform/fileManager";
@@ -17,8 +17,7 @@ import {
} from "@/ui";
import { promptInput } from "@/workbench/inputDialogs";
import { confirm } from "@/workbench/messages";
import { projectInitials } from "@/workbench/projectColor";
import { subscribeTabColors, tabColorOverride, tabColorVars, tabColorsVersion } from "@/workbench/tabColors";
import { projectColorVars, projectInitials } from "@/workbench/projectColor";
import {
createGroup,
filterRecent,
@@ -50,23 +49,12 @@ export async function askRemoveRecent(project: RecentProject, before?: () => voi
if (ok) await removeRecent(project.path);
}
/** Rounded-square project avatar; same colour and initials as the title bar's project widget. */
export function ProjectBadge({
name,
path,
className,
missing,
}: {
name: string;
path: string;
className?: string;
missing?: boolean;
}) {
useSyncExternalStore(subscribeTabColors, tabColorsVersion);
/** Rounded-square project avatar; same colour slot and initials as the title bar's project widget. */
export function ProjectBadge({ name, className, missing }: { name: string; className?: string; missing?: boolean }) {
return (
<span
className={clsx(styles.tile, missing && styles.tileMissing, className)}
style={tabColorVars(name, tabColorOverride(path))}
style={projectColorVars(name)}
aria-hidden
>
{projectInitials(name)}
@@ -210,7 +198,7 @@ function RecentRow({
const when = relativeTime(m.project.openedAtMs);
return (
<div className={styles.recent} title={unavailableTitle(m.project)}>
<ProjectBadge name={m.project.name} path={m.project.path} missing={!!m.project.missing} />
<ProjectBadge name={m.project.name} missing={!!m.project.missing} />
<span className={styles.recentText}>
<span className={styles.recentTop}>
<HighlightedText
+1 -17
Переглянути файл
@@ -1,6 +1,4 @@
{
"Problems actions": "Problems actions",
"TODO actions": "TODO actions",
"Same as the existing configuration '{existing}'": "Same as the existing configuration '{existing}'",
"Windows file and folder names cannot end with a period or space": "Windows file and folder names cannot end with a period or space",
"Use URL template": "Use URL template",
@@ -1260,8 +1258,6 @@
"Plan {done}/{length}": "Plan {done}/{length}",
"1 changed file": "1 changed file",
"{count} changed files": "{count} changed files",
"{count} more notification": "{count} more notification",
"{count} more notifications": "{count} more notifications",
"Send into the agent's turn": "Send into the agent's turn",
"Queue a message for when the agent is done (⌘⇧↵ sends it now)": "Queue a message for when the agent is done (⌘⇧↵ sends it now)",
"Queue a message for when the agent is done": "Queue a message for when the agent is done",
@@ -2625,8 +2621,6 @@
"Hot reload on save": "Hot reload on save",
"Saving a Dart file of a running Flutter debug session reloads the app, unless the file has errors.": "Saving a Dart file of a running Flutter debug session reloads the app, unless the file has errors.",
"Hot reload on save failed: {0}": "Hot reload on save failed: {0}",
"Projects can be opened in a new window, replace the current project, be attached to the already opened projects, or open as a new tab of this window.\nHow would you like to open \"{name}\"?": "Projects can be opened in a new window, replace the current project, be attached to the already opened projects, or open as a new tab of this window.\nHow would you like to open \"{name}\"?",
"New Tab": "New Tab",
"Show Only Widgets": "Show Only Widgets",
"Update failed": "Update failed",
"Updating branches": "Updating branches",
@@ -2653,16 +2647,6 @@
"{path} is a directory": "{path} is a directory",
"Cannot export test results": "Cannot export test results",
"Test results exported": "Test results exported",
"Olive": "Olive",
"Teal": "Teal",
"Custom colour hex": "Custom colour hex",
"Reset to Default": "Reset to Default",
"Always update snapshots": "Always update snapshots",
"Checks remote repositories for newer SNAPSHOT dependencies on every sync, build and run (-U).": "Checks remote repositories for newer SNAPSHOT dependencies on every sync, build and run (-U).",
"Automatic (the agent of the latest task)": "Automatic (the agent of the latest task)",
"The agent's current model": "The agent's current model",
"The agent's default": "The agent's default",
"Commit messages are short: a fast model with low effort is usually enough.": "Commit messages are short: a fast model with low effort is usually enough.",
"Change Project Color…": "Change Project Color…",
"Project Color": "Project Color"
"Checks remote repositories for newer SNAPSHOT dependencies on every sync, build and run (-U).": "Checks remote repositories for newer SNAPSHOT dependencies on every sync, build and run (-U)."
}
Loaded 100 of 118 files, more files were not shown because too many files have changed in this diff. Show more