Files
luxe/crates/luxe-cli/src/workspace_data.rs
Evan Whittaker a0666d6c81 luxe 0.1.4: remembered models, wheel-driven lists, and a steadier phone app
- luxe starts on the model you last chose in this project, then the last one anywhere. Signing in
  opens the model picker instead of choosing for you.
- Every list in a modal takes the mouse wheel and a draggable scrollbar.
- The phone app shows reasoning in full, stays put while you read back through a long session, and
  shows a question's answer on its card.
- On Windows, luxe update replaces the running luxe, and a signed-in install no longer sees setup
  again.
- The file tree no longer shows "engine busy" in a large project, loop output is easier to follow,
  and the name is written lowercase.

The CHANGELOG has the full list.
2026-10-20 13:51:34 -05:00

350 lines
15 KiB
Rust

//! Workspace data — project identity collection at the binary boundary.
//!
//! The collector owns project inspection so front-ends only reduce the resulting
//! [`luxe_core::WorkspaceSnapshot`].
use crate::git_probe;
use luxe_core::external_work::ExternalWork;
use luxe_core::lsp::{DiagnosticsStore, Severity};
use luxe_core::redact::redact_secrets;
use luxe_core::{
DiagnosticsSummary, FileDiagnostics, ProjectIdentity, ReviewSummary, SessionSummary,
WorkspaceScopeId, WorkspaceSnapshot,
};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, Ordering};
mod changes;
mod external;
mod todos;
use changes::collect_change_summary;
use external::collect_external_summary;
use todos::collect_todo_summary;
static NEXT_SCOPE: AtomicU64 = AtomicU64::new(1);
/// Collects revisioned workspace snapshots for one opened project.
pub(crate) struct WorkspaceCollector {
/// The checkout the agent works in: changes, identity, diagnostics
root: PathBuf,
/// The project whose `.luxe/` holds the session's todos and transcript
state_root: PathBuf,
scope_id: WorkspaceScopeId,
revision: u64,
session: Option<SessionSummary>,
/// Whether the session title has been derived from the first user message yet.
session_title_resolved: bool,
review: Option<ReviewSummary>,
/// Shared cache of the latest per-file LSP diagnostics, published by the edit hook.
diagnostics: DiagnosticsStore,
/// Shared warm LSP service, read for running-server state (`/lsp`). `None` in tests.
lsp_service: Option<crate::engine_setup::SharedLspService>,
/// Shared warm DAP service, read for live debug sessions (`/debug`). `None` in tests.
dap_service: Option<std::sync::Arc<luxe_dap::DapService>>,
/// Shared record of what this session changed outside the project, written by the hook.
external: ExternalWork,
/// The branch's pull request, as the watch last reported it
pull_request: luxe_core::workspace::PullRequestPresence,
}
/// Bounded number of offending files carried on the snapshot's diagnostics roll-up.
const DIAGNOSTICS_FILE_LIMIT: usize = 8;
impl WorkspaceCollector {
/// Creates a collector for one project-open generation, reading the process-wide diagnostics
/// cache the edit hook publishes to.
pub(crate) fn new(root: PathBuf) -> Self {
let mut collector =
Self::with_diagnostics_store(root, crate::engine_setup::shared_diagnostics_store());
collector.lsp_service = Some(crate::engine_setup::build_lsp_service());
collector.dap_service = Some(crate::engine_setup::shared_dap_service());
collector
}
fn with_diagnostics_store(root: PathBuf, diagnostics: DiagnosticsStore) -> Self {
let generation = NEXT_SCOPE.fetch_add(1, Ordering::Relaxed);
let scope_id = WorkspaceScopeId::new(format!("{}-{generation}", std::process::id()));
Self {
state_root: root.clone(),
root,
scope_id,
revision: 0,
session: None,
session_title_resolved: false,
review: None,
diagnostics,
lsp_service: None,
dap_service: None,
external: crate::engine_setup::shared_external_work(),
pull_request: luxe_core::workspace::PullRequestPresence::default(),
}
}
/// Reads the session's state from `state_root` rather than the checkout it works in.
pub(crate) fn with_state_root(mut self, state_root: PathBuf) -> Self {
self.state_root = state_root;
self
}
/// Reads external work from an explicit record rather than the process-wide one.
#[cfg(test)]
fn with_external_work(mut self, external: ExternalWork) -> Self {
self.external = external;
self
}
/// Records the session that owns later snapshots. Its title starts empty and fills in from the
/// first user message on the next [`WorkspaceCollector::collect`] — a brand-new session stays
/// untitled (no session id shown). Its plan comes from the session's own checklist, empty for
/// a fresh session, so the dock reads clean until work begins.
pub(crate) fn set_session(&mut self, session_id: impl Into<String>) {
let id = session_id.into();
self.session = Some(SessionSummary { id, title: String::new(), updated_at_ms: now_ms() });
self.session_title_resolved = false;
}
/// Records the immutable review currently selected by the workspace.
///
/// The finding count comes from the feedback session, not from here: a freshly loaded review
/// has none yet, and [`Self::set_review_findings`] keeps the dock honest as they accumulate.
pub(crate) fn set_guided_review(&mut self, review: &luxe_core::guided_review::GuidedReview) {
let unresolved_findings = self
.review
.as_ref()
.filter(|summary| summary.id == review.id.as_str())
.map_or(0, |summary| summary.unresolved_findings);
self.review = Some(ReviewSummary {
id: review.id.as_str().to_string(),
title: review.context.title.clone(),
source: luxe_core::guided_review::pull_request_label(review)
.unwrap_or_else(|| review_source_label(&review.target)),
unresolved_findings,
completed_at_ms: review.generated_at_ms,
});
}
/// Updates the dock's open-finding count from the persisted feedback session.
///
/// It was hardcoded to zero, so the REVIEW section always claimed "0 open findings" no matter
/// how many comments the reviewer had written.
pub(crate) fn set_review_findings(
&mut self,
session: &luxe_core::guided_review::ReviewSession,
) {
use luxe_core::guided_review::FindingState;
let unresolved_findings = session
.findings
.iter()
.filter(|finding| {
matches!(
finding.state,
FindingState::Draft | FindingState::Open | FindingState::NeedsVerification
)
})
.count();
match self.review.as_mut() {
Some(summary) if summary.id == session.id.as_str() => {
summary.unresolved_findings = unresolved_findings;
}
_ => {}
}
}
/// Collects the project identity section without blocking the runtime.
pub(crate) async fn collect(&mut self) -> WorkspaceSnapshot {
self.revision += 1;
self.resolve_session_title().await;
let todo_root = self.state_root.clone();
let change_root = self.root.clone();
// The plan follows the *session's* checklist (empty for a fresh session), so the dock never
// carries an unrelated session's todos.
let session_id = self.session.as_ref().map(|session| session.id.clone());
let (project, todos, changes) = tokio::join!(
project_identity(&self.root),
collect_todo_summary(todo_root, session_id),
collect_change_summary(change_root),
);
let mut snapshot = WorkspaceSnapshot::empty(self.scope_id.clone(), project);
snapshot.revision = self.revision;
snapshot.session = self.session.clone();
snapshot.todos = todos;
snapshot.changes = changes;
snapshot.external = collect_external_summary(self.external.record(), &self.root).await;
snapshot.review = self.review.clone();
snapshot.diagnostics = self.diagnostics_summary();
snapshot.tooling = self.tooling_summary().await;
snapshot.pull_request = self.pull_request.clone();
// Working in a worktree: it is still the project, named as such, and the snapshot says
// which checkout it describes
if self.state_root != self.root {
snapshot.project.display_name = luxe_core::paths::dir_name(&self.state_root);
let place = self.root.strip_prefix(&self.state_root).unwrap_or(&self.root);
snapshot.worktree = Some(luxe_core::paths::display(place));
}
snapshot
}
/// Records what the pull request watch found, for the next snapshot to carry.
pub(crate) fn set_pull_request(&mut self, presence: luxe_core::workspace::PullRequestPresence) {
self.pull_request = presence;
}
/// Rebuild the LSP-server + debug-adapter status for `/lsp` and `/debug`. Requires the shared
/// services (present in production via [`WorkspaceCollector::new`]); empty in service-less
/// tests.
async fn tooling_summary(&self) -> luxe_core::ToolingSummary {
match (&self.lsp_service, &self.dap_service) {
(Some(lsp), Some(dap)) => {
crate::engine_setup::collect_tooling_summary(&self.root, lsp, dap).await
}
_ => luxe_core::ToolingSummary::default(),
}
}
/// Reduces the shared diagnostics cache to a bounded, worst-first summary for the snapshot.
///
/// Only files under the active project root are counted (so a prior project's diagnostics never
/// leak after a switch), paths are made project-relative, and files sort by errors then
/// warnings so the most broken ones surface first.
fn diagnostics_summary(&self) -> DiagnosticsSummary {
let mut files: Vec<FileDiagnostics> = self
.diagnostics
.snapshot()
.into_iter()
.filter_map(|(path, diagnostics)| {
// Scope to the active project: a file outside the root (e.g. left over from a
// prior project) is dropped rather than shown with an absolute path.
let relative = path.strip_prefix(&self.root).ok()?;
let mut file =
FileDiagnostics { path: relative.to_path_buf(), ..Default::default() };
for diagnostic in &diagnostics {
match diagnostic.severity {
Some(Severity::Error) => file.errors += 1,
Some(Severity::Warning) => file.warnings += 1,
Some(Severity::Information) => file.infos += 1,
Some(Severity::Hint) => file.hints += 1,
None => {}
}
}
// Only files with an error or warning are listed; info/hint-only files are the
// kind of advice nothing acts on and they would crowd out the ones that matter.
(file.errors + file.warnings > 0).then_some(file)
})
.collect();
// Worst-first: errors, then warnings, then a stable path tiebreak.
files.sort_by(|left, right| {
right
.errors
.cmp(&left.errors)
.then(right.warnings.cmp(&left.warnings))
.then(left.path.cmp(&right.path))
});
let mut summary = DiagnosticsSummary {
total_files: files.len(),
truncated: files.len() > DIAGNOSTICS_FILE_LIMIT,
..DiagnosticsSummary::default()
};
for file in &files {
summary.errors += file.errors;
summary.warnings += file.warnings;
summary.infos += file.infos;
summary.hints += file.hints;
}
files.truncate(DIAGNOSTICS_FILE_LIMIT);
summary.files = files;
summary
}
/// Derives the session title from its first user message (opencode-style), once available.
///
/// Retries across collects until the first user message exists (a brand-new session has none
/// yet), then caches so later refreshes don't re-read the transcript.
async fn resolve_session_title(&mut self) {
if self.session_title_resolved {
return;
}
let Some(session) = self.session.as_ref() else {
return;
};
let (root, id) = (self.state_root.clone(), session.id.clone());
let derived = tokio::task::spawn_blocking(move || derive_session_title(&root, &id))
.await
.ok()
.flatten();
if let Some(title) = derived {
if let Some(session) = self.session.as_mut() {
session.title = title;
}
self.session_title_resolved = true;
}
}
}
/// Reads a session's first user message and reduces it to a bounded, single-line title.
fn derive_session_title(root: &Path, session_id: &str) -> Option<String> {
use luxe_core::session::{SessionId, SessionStore};
let store = crate::engine_setup::open_session_store(root);
let entries = store.load(&SessionId(session_id.to_string())).ok()?;
crate::dashboard_data::first_user_text(&entries)
.map(|text| bounded_title(&text))
.filter(|title| !title.is_empty())
}
/// Collapses whitespace to single spaces and bounds the title for the identity row.
fn bounded_title(text: &str) -> String {
bounded_text(&text.split_whitespace().collect::<Vec<_>>().join(" "), 60)
}
fn now_ms() -> u64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |duration| duration.as_millis() as u64)
}
fn bounded_text(text: &str, limit: usize) -> String {
let redacted = redact_secrets(text, &[]);
let mut value = redacted.chars().take(limit).collect::<String>();
if redacted.chars().nth(limit).is_some() {
value.push('…');
}
value
}
/// luxe's own project directory, excluded from what it reports as *your* changes.
const LUXE_PROJECT_DIR: &str = ".luxe";
async fn project_identity(root: &Path) -> ProjectIdentity {
let (git_branch, git_dirty, git_head) =
tokio::join!(git_probe::branch(root), git_probe::is_dirty(root), git_probe::head(root));
ProjectIdentity {
root: root.to_path_buf(),
display_name: luxe_core::paths::dir_name(root),
display_path: luxe_core::paths::home_relative(root),
git_branch,
git_dirty,
git_head,
}
}
/// What a review compares against, for the dock's REVIEW line — the target the reviewer actually
/// chose, not always "last turn".
fn review_source_label(target: &luxe_core::guided_review::ReviewTarget) -> String {
use luxe_core::guided_review::ReviewTarget;
match target {
ReviewTarget::WorkingTree => "working tree".into(),
ReviewTarget::LastTurn { .. } => "last turn".into(),
ReviewTarget::Base { reference } => format!("base {reference}"),
ReviewTarget::Commit { oid } => {
format!("commit {}", oid.chars().take(12).collect::<String>())
}
ReviewTarget::PullRequest { number, .. } => format!("pull request #{number}"),
ReviewTarget::OwnPullRequest { number } => format!("pull request #{number}"),
}
}
#[cfg(test)]
mod tests;