Initial public release

Luxe 0.1.0: a coding agent harness for the terminal. See README.md to get started and CHANGELOG.md for releases.
This commit is contained in:
Evan Whittaker
2026-10-17 12:08:30 -05:00
commit 09a7de2520
1730 changed files with 412952 additions and 0 deletions

View File

@@ -0,0 +1,126 @@
//! Reads — when `/github` asks for a row's detail, and where the answer lands.
//!
//! The cursor has to rest on a row for a moment before it is read, so holding Down through a list
//! asks for the row you stop on rather than every row you passed; each row is read once, until a
//! refresh forgets them all. An answer is matched to its row by repository and number, so one that
//! arrives after the reader moved on still lands where it belongs.
use luxe_core::github::ListItem;
use super::GithubPanel;
use crate::github_detail::GithubDetail;
/// How long the cursor rests on a row before its overview is read: holding Down through a list
/// asks for the row you stop on, not every row you passed.
const SETTLE: std::time::Duration = std::time::Duration::from_millis(250);
/// An overview to ask the engine for.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OverviewRead {
/// `owner/name` when it is not the checkout's repository
pub repository: Option<String>,
/// Its number
pub number: u64,
/// Whether it is a pull request, rather than an issue
pub pull_request: bool,
}
impl GithubPanel {
/// Watches the cursor, and answers the read to send once it has rested on a row that has not
/// been read: one read per row, however often the cursor passes through it.
pub fn due_read(&mut self, now: std::time::Instant) -> Option<OverviewRead> {
let item = self.rows().get(self.selected).copied().cloned()?;
let known = self.details.contains_key(&item.url)
|| self.failures.contains_key(&item.url)
|| self.asked.contains(&item.url);
match &self.settling {
Some((url, _)) if *url != item.url => {
self.settling = Some((item.url, now));
None
}
None => {
self.settling = Some((item.url, now));
None
}
Some((_, since)) if known || now.duration_since(*since) < SETTLE => None,
Some(_) => {
self.asked.insert(item.url.clone());
let repository = self.elsewhere(&item).then(|| item.repository.clone());
Some(OverviewRead {
repository,
number: item.number,
pull_request: item.pull_request,
})
}
}
}
/// Whether the row under the cursor is still waiting on its overview.
pub fn reading(&self) -> bool {
self.rows().get(self.selected).is_some_and(|item| {
!self.details.contains_key(&item.url) && !self.failures.contains_key(&item.url)
})
}
/// Lands an overview, or why there is none, in the detail of the row it answers.
///
/// Args: `(repository, number, overview, error, local, branch)` — `repository` as asked, `None`
/// for the checkout's; `branch` the number of the checked-out branch's pull request, the only
/// one whose threads can be worked through here.
#[allow(clippy::too_many_arguments)]
pub fn land(
&mut self,
repository: Option<&str>,
number: u64,
overview: Option<luxe_core::github::overview::Overview>,
error: Option<String>,
local: Option<luxe_core::github::overview::LocalSession>,
branch: Option<u64>,
) {
let here = self.repository.clone();
let matches = |item: &ListItem| {
item.number == number
&& match repository {
Some(slug) => item.repository.eq_ignore_ascii_case(slug),
None => here
.as_deref()
.is_none_or(|here| here.eq_ignore_ascii_case(&item.repository)),
}
};
let Some(url) = self
.sections
.iter()
.flatten()
.flat_map(|section| &section.items)
.find(|item| matches(item))
.map(|item| item.url.clone())
else {
return;
};
self.asked.remove(&url);
match overview {
Some(overview) => {
let on_branch = repository.is_none()
&& matches!(overview, luxe_core::github::overview::Overview::PullRequest(_))
&& branch == Some(number);
let mut detail = GithubDetail::new(overview);
detail.on_branch = on_branch;
detail.local = local;
self.failures.remove(&url);
self.details.insert(url, detail);
}
None => {
let reason = error.unwrap_or_else(|| "No answer from GitHub".into());
self.failures.insert(url, reason);
}
}
}
/// Forgets every overview read, so the next look at each row reads it again.
pub fn forget_details(&mut self) {
self.details.clear();
self.failures.clear();
self.asked.clear();
self.settling = None;
}
}