diff --git a/Cargo.lock b/Cargo.lock index 09d4db1d..a6fa5093 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -17,6 +17,20 @@ version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "const-random", + "getrandom 0.3.4", + "once_cell", + "version_check", + "zerocopy", +] + [[package]] name = "aho-corasick" version = "1.1.4" @@ -44,6 +58,21 @@ dependencies = [ "equator", ] +[[package]] +name = "alloc-no-stdlib" +version = "2.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3" + +[[package]] +name = "alloc-stdlib" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e76a019e91224d279006ff972f1e984179a6e9feb050adba6ce8274aef23195" +dependencies = [ + "alloc-no-stdlib", +] + [[package]] name = "alloca" version = "0.4.0" @@ -308,6 +337,12 @@ version = "0.22.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" +[[package]] +name = "base64" +version = "0.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5" + [[package]] name = "bit-set" version = "0.8.0" @@ -386,6 +421,27 @@ dependencies = [ "objc2", ] +[[package]] +name = "brotli" +version = "8.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5cc91aac060a7a1e25823bdccbfb6af1875b88f17c6daac97894eed8207166b3" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", + "brotli-decompressor", +] + +[[package]] +name = "brotli-decompressor" +version = "5.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a32acac15fe1967bc3986b2a6347dffc965602354ea6f450ad07e8bfd253583" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", +] + [[package]] name = "built" version = "0.8.1" @@ -524,7 +580,7 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f1f927b07c74ba84c7e5fe4db2baeb3e996ab2688992e39ac68ce3220a677c7e" dependencies = [ - "base64", + "base64 0.22.1", "encoding_rs", ] @@ -642,6 +698,26 @@ version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c" +[[package]] +name = "const-random" +version = "0.1.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359" +dependencies = [ + "const-random-macro", +] + +[[package]] +name = "const-random-macro" +version = "0.1.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e" +dependencies = [ + "getrandom 0.2.17", + "once_cell", + "tiny-keccak", +] + [[package]] name = "const-serialize" version = "0.7.2" @@ -1217,7 +1293,7 @@ checksum = "236deb81f1a04de704fb80cf7838c65607441c76914de2e036709540c540a39d" dependencies = [ "anyhow", "async-trait", - "base64", + "base64 0.22.1", "bytes", "cocoa", "core-foundation", @@ -1325,7 +1401,7 @@ dependencies = [ "async-tungstenite", "axum", "axum-core", - "base64", + "base64 0.22.1", "bytes", "ciborium", "const-str", @@ -1379,7 +1455,7 @@ checksum = "0011e9bca8da2ae6bf02ba9ef93ba6c5fa539e402de3aeb316ad86ca77c59079" dependencies = [ "anyhow", "axum-core", - "base64", + "base64 0.22.1", "ciborium", "dioxus-core", "dioxus-document", @@ -1640,6 +1716,15 @@ dependencies = [ "syn 2.0.119", ] +[[package]] +name = "dlib" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a" +dependencies = [ + "libloading 0.7.4", +] + [[package]] name = "dlopen2" version = "0.8.2" @@ -1672,6 +1757,12 @@ dependencies = [ "litrs", ] +[[package]] +name = "downcast-rs" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2" + [[package]] name = "dpi" version = "0.1.2" @@ -1855,6 +1946,7 @@ checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" dependencies = [ "crc32fast", "miniz_oxide", + "zlib-rs", ] [[package]] @@ -2471,6 +2563,7 @@ checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" dependencies = [ "cfg-if", "crunchy", + "num-traits", "zerocopy", ] @@ -2507,7 +2600,7 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b3314d5adb5d94bcdf56771f2e50dbbc80bb4bdf88967526706205ac9eff24eb" dependencies = [ - "base64", + "base64 0.22.1", "bytes", "headers-core", "http", @@ -2645,7 +2738,7 @@ version = "0.1.20" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0" dependencies = [ - "base64", + "base64 0.22.1", "bytes", "futures-channel", "futures-util", @@ -3269,6 +3362,15 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154" +[[package]] +name = "lz4_flex" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecbdfe44b1bd960b68170b417450a628c43f7cf56bb3c5317e61cb230ee7f226" +dependencies = [ + "twox-hash", +] + [[package]] name = "mac" version = "0.1.1" @@ -3621,6 +3723,16 @@ dependencies = [ "num-traits", ] +[[package]] +name = "num-bigint" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93e7820bc0a80a0238e650327316f929ba18d5be054b647490a3a6a339f3e7c0" +dependencies = [ + "num-integer", + "num-traits", +] + [[package]] name = "num-complex" version = "0.4.6" @@ -3663,7 +3775,7 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824" dependencies = [ - "num-bigint", + "num-bigint 0.4.8", "num-integer", "num-traits", ] @@ -3675,6 +3787,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" dependencies = [ "autocfg", + "libm", ] [[package]] @@ -3942,6 +4055,32 @@ dependencies = [ "windows-link 0.2.1", ] +[[package]] +name = "parquet" +version = "59.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7065842956a20c2a536924ce8e4d9955f7422451511b9eb7500d7bfe5077e59c" +dependencies = [ + "ahash", + "base64 0.23.1", + "brotli", + "bytes", + "chrono", + "crc32fast", + "flate2", + "half", + "hashbrown 0.17.1", + "lz4_flex", + "num-bigint 0.5.1", + "num-integer", + "num-traits", + "seq-macro", + "simdutf8", + "snap", + "twox-hash", + "zstd", +] + [[package]] name = "paste" version = "1.0.15" @@ -4358,6 +4497,15 @@ version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3" +[[package]] +name = "quick-xml" +version = "0.41.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e660451e55124f798a69a5af3f49ccfbefbd41910eefd25caf2393e1f3473ec1" +dependencies = [ + "memchr", +] + [[package]] name = "quinn" version = "0.11.11" @@ -4732,7 +4880,7 @@ version = "0.12.28" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147" dependencies = [ - "base64", + "base64 0.22.1", "bytes", "cookie", "cookie_store", @@ -4790,6 +4938,9 @@ dependencies = [ "raw-window-handle 0.6.2", "wasm-bindgen", "wasm-bindgen-futures", + "wayland-backend", + "wayland-client", + "wayland-protocols", "web-sys", "windows-sys 0.61.2", ] @@ -5030,6 +5181,12 @@ dependencies = [ "futures-core", ] +[[package]] +name = "seq-macro" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc" + [[package]] name = "serde" version = "1.0.229" @@ -5288,9 +5445,12 @@ version = "0.1.0" dependencies = [ "chrono", "dioxus", + "dirs", "futures-util", "js-sys", + "parquet", "reqwest", + "rfd", "rusqlite", "serde", "serde_json", @@ -5354,6 +5514,12 @@ version = "1.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90" +[[package]] +name = "snap" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "199905e6153d6405f9728fe44daace35f8f837bbf830bb6e85fbd5828709a886" + [[package]] name = "socket2" version = "0.6.5" @@ -5724,6 +5890,15 @@ dependencies = [ "time-core", ] +[[package]] +name = "tiny-keccak" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237" +dependencies = [ + "crunchy", +] + [[package]] name = "tinystr" version = "0.8.3" @@ -6067,6 +6242,12 @@ dependencies = [ "utf-8", ] +[[package]] +name = "twox-hash" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8464ec13c3691491391d9fce00f6416c9a48e46972f72d7865688be2080192c9" + [[package]] name = "type-map" version = "0.5.1" @@ -6344,6 +6525,66 @@ dependencies = [ "web-sys", ] +[[package]] +name = "wayland-backend" +version = "0.3.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "016ccf01d1c58b6f8999612813e17c9b2390f7d70671428869913310f83f54b8" +dependencies = [ + "cc", + "downcast-rs", + "rustix", + "scoped-tls", + "smallvec", + "wayland-sys", +] + +[[package]] +name = "wayland-client" +version = "0.31.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3c36a0f861ad76d0901f2800b46321410d9f73f2ea88aac0650d86c32688073" +dependencies = [ + "bitflags 2.13.1", + "rustix", + "wayland-backend", + "wayland-scanner", +] + +[[package]] +name = "wayland-protocols" +version = "0.32.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23d0c813de3daa2ed6520af85a3bd49b0e722a3078506899aa9686fea58dc4b6" +dependencies = [ + "bitflags 2.13.1", + "wayland-backend", + "wayland-client", + "wayland-scanner", +] + +[[package]] +name = "wayland-scanner" +version = "0.31.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "338e30461b3a2b67d70eb30a6d89f8e0c93a833e07d2ae89085cd070c4a00ac0" +dependencies = [ + "proc-macro2", + "quick-xml", + "quote", +] + +[[package]] +name = "wayland-sys" +version = "0.31.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be" +dependencies = [ + "dlib", + "log", + "pkg-config", +] + [[package]] name = "web-sys" version = "0.3.103" @@ -6939,7 +7180,7 @@ version = "0.53.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "728b7d4c8ec8d81cab295e0b5b8a4c263c0d41a785fb8f8c4df284e5411140a2" dependencies = [ - "base64", + "base64 0.22.1", "block2", "cookie", "crossbeam-channel", @@ -7136,6 +7377,12 @@ dependencies = [ "syn 2.0.119", ] +[[package]] +name = "zlib-rs" +version = "0.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34b31d188d9d685a4f9c7b46d6e36631b07058d2cfe190267adce54dc230bf12" + [[package]] name = "zmij" version = "1.0.23" diff --git a/assets/icons/line/settings.svg b/assets/icons/line/settings.svg new file mode 100644 index 00000000..01a76ccf --- /dev/null +++ b/assets/icons/line/settings.svg @@ -0,0 +1,5 @@ + + + + + diff --git a/crates/sl-viewer/Cargo.toml b/crates/sl-viewer/Cargo.toml index f22ba4a6..a61790b2 100644 --- a/crates/sl-viewer/Cargo.toml +++ b/crates/sl-viewer/Cargo.toml @@ -21,15 +21,28 @@ rusqlite = { version = "0.40", optional = true } zstd = { version = "0.13", optional = true } wasm-bindgen = { version = "0.2", optional = true } web-sys = { version = "0.3", optional = true, features = ["Document", "Element", "Event", "EventSource", "HtmlElement", "KeyboardEvent", "Location", "MessageEvent", "UrlSearchParams", "Window"] } +# parquet feature: ingest Claude conversation parquet exports under ~/.claude/projects. +# Uses the row-based API (no arrow) for minimal dependency footprint. +parquet = { version = "59", optional = true, default-features = false, features = ["snap", "zstd", "brotli", "flate2-zlib-rs", "lz4", "base64", "simdutf8", "crc"] } +# Native folder-picker dialog for the "Pick folder…" affordance (desktop only). +# Uses `rfd`'s cocoa backend on macOS, native Win32 dialogs on Windows, and +# the XDG-portal/GTK3 stack on Linux. Default features are required on +# Linux so the dialog can talk to a portal service. +rfd = { version = "0.17", optional = true } +# Resolve the platform config directory for persisted corpus paths. +dirs = "6" [dev-dependencies] rusqlite = "0.40" zstd = "0.13" tempfile = "3" +# Pull parquet into the test build so fixture writers and unit tests can exercise +# the parquet source even when the production `parquet` feature is disabled. +parquet = { version = "59", default-features = false, features = ["snap", "zstd", "brotli", "flate2-zlib-rs", "lz4", "base64", "simdutf8", "crc"] } [features] default = ["desktop"] -desktop = ["dioxus/desktop", "dep:reqwest", "dep:tokio", "dep:tokio-util", "dep:futures-util", "dep:chrono", "compressed-sessions"] +desktop = ["dioxus/desktop", "dep:reqwest", "dep:tokio", "dep:tokio-util", "dep:futures-util", "dep:chrono", "dep:rfd", "compressed-sessions"] compressed-sessions = ["dep:zstd", "session-ledger/compress"] web = ["dioxus/web", "dep:reqwest", "dep:futures-util", "dep:js-sys", "dep:wasm-bindgen", "dep:web-sys"] # Enable loading real Forge SQLite sessions in the viewer. @@ -39,6 +52,10 @@ sqlite = [ "dep:zstd", "session-ledger/sqlite", ] +# Enable ingesting Claude conversation parquet exports (e.g. files dropped under +# `~/.claude/projects/*.parquet`). Without this feature, parquet files are +# silently skipped by the auto-discovery loader. +parquet = ["dep:parquet"] [lints.rust] unsafe_code = "forbid" diff --git a/crates/sl-viewer/src/app.rs b/crates/sl-viewer/src/app.rs index 27a66146..942f5fe4 100644 --- a/crates/sl-viewer/src/app.rs +++ b/crates/sl-viewer/src/app.rs @@ -7,8 +7,9 @@ use session_ledger::domain::{ use crate::async_states::{ErrorColorFixture, ErrorState, FirstRunEmpty, LoadingState}; use crate::bundle_diff::{BundleDiff, OkfBundle}; use crate::bundle_list::{summarize, BundleSummary}; +use crate::cli_help; use crate::command_palette::{CommandPalette, PaletteAction}; -use crate::corpus_loader::{load_sessions, DataSource}; +use crate::corpus_loader::{load_sessions_with_custom, CustomCorpusPath, DataSource}; use crate::corpus_tab::CorpusTab; use crate::detail_pane::{extract_detail, BundleDetail}; use crate::fixture::visual_fixture_active; @@ -20,7 +21,9 @@ use crate::memory_tab::MemoryWiki; use crate::replay_view::ReplayView; use crate::search_view::SearchView; use crate::session_transcript::SessionTranscript; -use crate::theme::ThemeColors; +use crate::settings::{DefaultTab, Settings}; +use crate::settings_tab::SettingsTab; +use crate::theme::{Theme, ThemeColors}; use crate::timeline::TimelineView; use crate::tokens::{TOKENS_CSS, VIEWER_COLOR_SCHEME}; use crate::unfinished_tab::UnfinishedWork; @@ -40,10 +43,13 @@ enum Tab { /// other tab derives from, so users can see what was discovered and reload /// discovery on demand. (FR-RAW-1) Corpus, + /// Persistent user preferences (theme, default tab, daemon URL, version). + /// (FR-VIEWER-SETTINGS-1) + Settings, } impl Tab { - const ALL: [Tab; 9] = [ + const ALL: [Tab; 10] = [ Tab::Bundles, Tab::History, Tab::Unfinished, @@ -53,6 +59,7 @@ impl Tab { Tab::Timeline, Tab::Replay, Tab::Corpus, + Tab::Settings, ]; fn label(self) -> &'static str { @@ -66,6 +73,7 @@ impl Tab { Tab::Timeline => "Timeline", Tab::Replay => "Replay", Tab::Corpus => "Raw Sessions", + Tab::Settings => "Settings", } } @@ -80,6 +88,7 @@ impl Tab { Tab::Timeline => "tab-timeline", Tab::Replay => "tab-replay", Tab::Corpus => "tab-corpus", + Tab::Settings => "tab-settings", } } @@ -94,6 +103,7 @@ impl Tab { Tab::Timeline => "panel-timeline", Tab::Replay => "panel-replay", Tab::Corpus => "panel-corpus", + Tab::Settings => "panel-settings", } } @@ -113,6 +123,7 @@ impl Tab { Self::Timeline => "timeline", Self::Replay => "replay", Self::Corpus => "corpus", + Self::Settings => "settings", } } @@ -121,6 +132,24 @@ impl Tab { } } +/// Map a persisted [`DefaultTab`] to its runtime [`Tab`] counterpart. +/// +/// [`DefaultTab`] deliberately omits [`Tab::Settings`] (we never auto-launch +/// into settings), so every variant maps cleanly. +fn default_tab_to_tab(t: DefaultTab) -> Tab { + match t { + DefaultTab::Bundles => Tab::Bundles, + DefaultTab::History => Tab::History, + DefaultTab::Unfinished => Tab::Unfinished, + DefaultTab::Memory => Tab::Memory, + DefaultTab::LiveFeed => Tab::LiveFeed, + DefaultTab::Search => Tab::Search, + DefaultTab::Timeline => Tab::Timeline, + DefaultTab::Replay => Tab::Replay, + DefaultTab::Corpus => Tab::Corpus, + } +} + /// Shared session data provided at the root of the component tree. /// /// Consumers call `use_context::()` to access the loaded sessions. @@ -131,6 +160,38 @@ pub struct SessionContext(pub Signal>); #[derive(Clone, Copy, Debug, PartialEq)] pub struct ReloadTrigger(pub Signal); +/// User-supplied corpus directories, persisted across launches. +/// +/// The wrapped signal is mutated by the Raw Sessions tab when the user +/// picks a new folder or resets to defaults. The discovery effect reads +/// the latest value on every re-run, so a pick immediately triggers a +/// reload without restarting the app. +#[derive(Clone, Debug, PartialEq)] +pub struct CustomCorpusPaths(pub Signal); + +impl CustomCorpusPaths { + /// Read the current custom paths snapshot. + pub fn snapshot(&self) -> CustomCorpusPath { + self.0.cloned() + } + + /// Replace the current custom paths (used by the Raw Sessions toolbar). + pub fn set(&mut self, paths: CustomCorpusPath) { + self.0.set(paths); + } + + /// Clear the override and revert to the default discovery set. + pub fn clear(&mut self) { + self.0.set(CustomCorpusPath::default()); + } +} + +/// Persisted user settings, exposed at the root so [`SettingsTab`] and +/// other consumers can read and update them. The settings are persisted +/// to disk by an effect that watches this signal. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct SettingsSignal(pub Signal); + /// Discovery status published at the root so every tab can render a /// loading / error / ready state without the App's spawn_blocking effect /// having to thread the status through props. The corpus scan can take @@ -164,6 +225,22 @@ fn resolve_data_source() -> DataSource { DataSource::Auto } +/// Load the persisted custom corpus paths at startup. +/// +/// Missing or unreadable files degrade silently to an empty +/// [`CustomCorpusPath`] — the viewer must always be able to launch, even +/// if the config directory is locked down. Parse errors are logged to +/// stderr so the operator notices but the UI does not break. +fn initial_custom_corpus_paths() -> CustomCorpusPath { + match crate::corpus_paths::load_config() { + Ok(config) => CustomCorpusPath::from(config.custom_paths), + Err(error) => { + eprintln!("[sl-viewer] custom corpus paths unavailable: {error}"); + CustomCorpusPath::default() + } + } +} + fn initial_tab_for_viewer() -> Tab { if query_fixture_active("history-empty") { Tab::History @@ -174,7 +251,10 @@ fn initial_tab_for_viewer() -> Tab { } else if query_fixture_active("stream-skeleton") { Tab::LiveFeed } else { - Tab::Bundles + // Honour the persisted default tab so a user who lands on Search + // every time does not have to click into it on every launch. + let persisted = Settings::load(); + default_tab_to_tab(persisted.default_tab) } } @@ -227,7 +307,6 @@ fn build_bundles_from_sessions(sessions: &[Session]) -> Vec } // `App` is a Dioxus component (mounted by name from main.rs / web entry). -#[allow(non_snake_case)] /// Inline SVG icons for each tab (loaded at compile time). const ICON_SVG_BUNDLES: &str = include_str!("../../../assets/icons/line/bundles.svg"); const ICON_SVG_HISTORY: &str = include_str!("../../../assets/icons/line/history.svg"); @@ -238,6 +317,7 @@ const ICON_SVG_LIVE: &str = include_str!("../../../assets/icons/line/live.svg"); const ICON_SVG_SEARCH: &str = include_str!("../../../assets/icons/line/search.svg"); const ICON_SVG_REPLAY: &str = include_str!("../../../assets/icons/line/replay.svg"); const ICON_SVG_CORPUS: &str = include_str!("../../../assets/icons/line/corpus.svg"); +const ICON_SVG_SETTINGS: &str = include_str!("../../../assets/icons/line/settings.svg"); /// Brand mascot (Getta) for the launch splash. Embedded at compile time so /// the splash renders even before the assets server is reachable. The 2.5D @@ -258,10 +338,14 @@ fn icon_svg(tab_icon: &str) -> &'static str { "search" => ICON_SVG_SEARCH, "replay" => ICON_SVG_REPLAY, "corpus" => ICON_SVG_CORPUS, + "settings" => ICON_SVG_SETTINGS, _ => ICON_SVG_BUNDLES, } } +// `App` is the Dioxus entry point — main.rs and the web launcher mount it +// by name, so the upper-case identifier is part of the public surface. +#[allow(non_snake_case)] pub fn App() -> Element { #[cfg(feature = "web")] use_effect(|| { @@ -303,27 +387,30 @@ pub fn App() -> Element { let mut error_signal: Signal> = use_signal(|| None); let mut loading_signal: Signal = use_signal(|| true); let reload_trigger: Signal = use_signal(|| 0u32); + let custom_paths_signal: Signal = use_signal(initial_custom_corpus_paths); use_context_provider(|| ReloadTrigger(reload_trigger)); - use_context_provider(|| DiscoveryState { - loading: loading_signal, - error: error_signal, - }); + use_context_provider(|| CustomCorpusPaths(custom_paths_signal)); + use_context_provider(|| DiscoveryState { loading: loading_signal, error: error_signal }); use_effect(move || { let _ = reload_trigger(); + let _ = custom_paths_signal(); loading_signal.set(true); error_signal.set(None); let source = resolve_data_source(); + let custom_snapshot = custom_paths_signal.cloned(); spawn(async move { let result: std::result::Result, String>, String> = { #[cfg(feature = "desktop")] { - tokio::task::spawn_blocking(move || load_sessions(&source)) - .await - .map_err(|error| error.to_string()) + tokio::task::spawn_blocking(move || { + load_sessions_with_custom(&source, &custom_snapshot) + }) + .await + .map_err(|error| error.to_string()) } #[cfg(not(feature = "desktop"))] { - Ok(load_sessions(&source)) + Ok(load_sessions_with_custom(&source, &custom_snapshot)) } }; loading_signal.set(false); @@ -342,9 +429,110 @@ pub fn App() -> Element { }); use_context_provider(|| SessionContext(sessions_signal)); - let mut active_tab: Signal = use_signal(initial_tab_for_viewer); + // Desktop menu bar wiring: dispatch each `muda::MenuEvent` to the same + // DOM controls the keyboard hotkeys already use, so a single source of + // truth owns state (palette, help, theme, reload). File → Reload + // Discovery is the one case that mutates Rust state directly because + // it triggers a fresh `tokio::spawn_blocking(load_sessions)` from the + // `use_effect` above. + #[cfg(feature = "desktop")] + { + let mut reload_trigger_for_menu = reload_trigger; + use dioxus::desktop::use_muda_event_handler; + use_muda_event_handler(move |event| { + use crate::menu::{ + ID_APP_ABOUT, ID_APP_SETTINGS, ID_EDIT_FIND, ID_FILE_RELOAD_DISCOVERY, + ID_FILE_SETTINGS, ID_HELP_TOGGLE, ID_VIEW_COMMAND_PALETTE, ID_VIEW_RELOAD, + ID_VIEW_TOGGLE_THEME, + }; + match event.id().0.as_str() { + ID_VIEW_COMMAND_PALETTE => { + let _ = document::eval( + "document.getElementById('viewer-palette-button')?.click();", + ); + } + ID_HELP_TOGGLE => { + let _ = + document::eval("document.getElementById('viewer-help-button')?.click();"); + } + ID_VIEW_TOGGLE_THEME => { + let _ = + document::eval("document.getElementById('viewer-theme-toggle')?.click();"); + } + ID_VIEW_RELOAD => { + // Cmd+R: re-fetch the corpus (same effect as the Raw + // Sessions tab's "Reload discovery" button). + reload_trigger_for_menu.with_mut(|t| *t = t.wrapping_add(1)); + } + ID_FILE_RELOAD_DISCOVERY => { + reload_trigger_for_menu.with_mut(|t| *t = t.wrapping_add(1)); + } + ID_EDIT_FIND => { + // Stub: focus the existing Search tab button so keyboard + // ⌘F opens the search pane. A dedicated search input + // focus is a follow-up; today the Search tab body owns + // its own keyboard listener. + let _ = document::eval("document.getElementById('tab-search')?.click();"); + } + ID_APP_SETTINGS | ID_FILE_SETTINGS => { + // Settings dialog is not implemented yet; surface a + // discoverable stub so users (and the visual-fixture + // suites) see the menu item work end-to-end. + let _ = document::eval( + "window.alert('SessionLedger settings are coming soon.\\n\\nSee docs/functional_requirements.md for the roadmap.');", + ); + } + ID_APP_ABOUT => { + let payload = cli_help::version_text().replace('\'', "\\'"); + let script = format!( + "window.alert('SessionLedger Viewer\\n\\n{}\\n\\nA hexagonal session-bundle compiler + viewer for OKF streams.');", + payload + ); + let _ = document::eval(&script); + } + _ => {} + } + }); + } + + // Persisted user settings (theme + default tab). Loaded once at mount; + // mutations propagate through `SettingsSignal` and the effect below + // persists them back to `settings.json`. + let initial_settings = Settings::load(); + let settings_signal = use_signal(|| initial_settings); + use_context_provider(|| SettingsSignal(settings_signal)); + let settings_for_persist = settings_signal; + use_effect(move || { + let snapshot = settings_for_persist(); + // Best-effort write — failures here should not crash the viewer. + if let Err(err) = snapshot.save() { + eprintln!("[sl-viewer] could not persist settings: {err}"); + } + // Mirror the persisted theme to the DOM dataset so CSS picks it up. + let theme_attr = match snapshot.theme { + Theme::Light => "light", + Theme::Dark => "dark", + Theme::System => "system", + }; + let _ = document::eval(&format!( + r#" + (function() {{ + const desired = {theme_attr:?}; + if (desired === 'system') {{ + const prefersLight = window.matchMedia + && window.matchMedia('(prefers-color-scheme: light)').matches; + const resolved = prefersLight ? 'light' : 'dark'; + document.documentElement.dataset.theme = resolved; + }} else {{ + document.documentElement.dataset.theme = desired; + }} + }})(); + "#, + )); + }); let mut help_open: Signal = use_signal(|| false); let mut palette_open: Signal = use_signal(|| false); + let mut active_tab: Signal = use_signal(initial_tab_for_viewer); let colors = ThemeColors::dark(); let mut close_help = move || { @@ -469,6 +657,11 @@ pub fn App() -> Element { let _ = document::eval(&script); }); + let mut activate = move |tab: Tab| { + active_tab.set(tab); + let _ = document::eval(&format!("document.getElementById('{}')?.focus();", tab.id())); + }; + let tab_body = match active_tab() { Tab::Bundles => rsx! { BundlesTab {} }, Tab::History => rsx! { HistoryTimeline {} }, @@ -482,11 +675,13 @@ pub fn App() -> Element { } Tab::Replay => rsx! { ReplayView {} }, Tab::Corpus => rsx! { CorpusTab {} }, - }; - - let mut activate = move |tab: Tab| { - active_tab.set(tab); - let _ = document::eval(&format!("document.getElementById('{}')?.focus();", tab.id())); + Tab::Settings => { + let on_open_corpus = move |_| { + active_tab.set(Tab::Corpus); + let _ = document::eval("document.getElementById('tab-corpus')?.focus();"); + }; + rsx! { SettingsTab { on_open_corpus_paths: on_open_corpus } } + } }; let run_palette_action = move |action: PaletteAction| { @@ -536,7 +731,22 @@ pub fn App() -> Element { ); } PaletteAction::ToggleTheme => { - let _ = document::eval("document.getElementById('viewer-theme-toggle')?.click();"); + // Legacy command: route through the Settings tab so the + // user's choice persists via the new settings store. + active_tab.set(Tab::Settings); + let _ = document::eval( + r#" + window.requestAnimationFrame(() => { + const themeInput = document.querySelector( + 'input[name="settings-theme"]:not(:checked)' + ); + themeInput?.focus(); + }); + "#, + ); + } + PaletteAction::OpenSettings => { + activate(Tab::Settings); } } }; @@ -991,7 +1201,7 @@ pub fn App() -> Element { } Key::End => { evt.prevent_default(); - activate(Tab::Corpus); + activate(Tab::Settings); } _ => {} } @@ -1054,19 +1264,30 @@ pub fn App() -> Element { id: "viewer-theme-toggle", class: "theme-toggle", r#type: "button", - "aria-label": "Toggle light and dark theme", + "aria-label": "Open settings to change theme", onclick: move |_| { + active_tab.set(Tab::Settings); let _ = document::eval( r#" - const root = document.documentElement; - const current = root.dataset.theme === 'light' ? 'light' : 'dark'; - const next = current === 'light' ? 'dark' : 'light'; - root.dataset.theme = next; - window.localStorage.setItem('sl-viewer-theme', next); + window.requestAnimationFrame(() => { + const focusable = document.querySelector( + '#settings-theme-radios input[type="radio"]' + ); + focusable?.focus(); + }); "#, ); }, - "Toggle Theme" + "Theme" + } + button { + id: "viewer-settings-button", + class: "help-toggle", + r#type: "button", + "aria-haspopup": "tab", + "aria-controls": "panel-settings", + onclick: move |_| activate(Tab::Settings), + "Settings" } } HelpOverlay { @@ -1157,8 +1378,8 @@ fn BundlesTab() -> Element { }; } - let summaries: Vec = bundles.iter().map(|b| summarize(&b)).collect(); - let detail = selected_idx().and_then(|idx| bundles.get(idx)).map(|b| extract_detail(&b)); + let summaries: Vec = bundles.iter().map(summarize).collect(); + let detail = selected_idx().and_then(|idx| bundles.get(idx)).map(extract_detail); // Determine if we should show the diff panel. let diff_pair: Option<(OkfBundle, OkfBundle)> = diff --git a/crates/sl-viewer/src/command_palette.rs b/crates/sl-viewer/src/command_palette.rs index 949e3ac0..e09ff256 100644 --- a/crates/sl-viewer/src/command_palette.rs +++ b/crates/sl-viewer/src/command_palette.rs @@ -8,6 +8,7 @@ pub enum PaletteAction { FocusSearch, ToggleTheme, OpenHelp, + OpenSettings, NextTab, PrevTab, ClearSearch, @@ -22,7 +23,8 @@ pub struct PaletteCommand { pub action: PaletteAction, } -/// Power-user command set for Wave-29 C09 (L81.14). +/// Power-user command set for Wave-29 C09 (L81.14), extended with +/// `OpenSettings` (FR-VIEWER-SETTINGS-1). pub const COMMANDS: &[PaletteCommand] = &[ PaletteCommand { id: "focus-search", @@ -30,6 +32,12 @@ pub const COMMANDS: &[PaletteCommand] = &[ hint: "Switch to Search and focus the first filter", action: PaletteAction::FocusSearch, }, + PaletteCommand { + id: "open-settings", + label: "Open settings", + hint: "Switch to the Settings tab (theme, default tab, daemon)", + action: PaletteAction::OpenSettings, + }, PaletteCommand { id: "open-help", label: "Open keyboard help", @@ -39,7 +47,7 @@ pub const COMMANDS: &[PaletteCommand] = &[ PaletteCommand { id: "next-tab", label: "Next view tab", - hint: "Select and focus the next tab, wrapping at Replay", + hint: "Select and focus the next tab, wrapping at Settings", action: PaletteAction::NextTab, }, PaletteCommand { @@ -182,19 +190,21 @@ mod tests { assert!(COMMANDS.iter().any(|c| c.action == PaletteAction::FocusSearch)); assert!(COMMANDS.iter().any(|c| c.action == PaletteAction::ToggleTheme)); assert!(COMMANDS.iter().any(|c| c.action == PaletteAction::OpenHelp)); + assert!(COMMANDS.iter().any(|c| c.action == PaletteAction::OpenSettings)); assert!(COMMANDS.iter().any(|c| c.action == PaletteAction::NextTab)); assert!(COMMANDS.iter().any(|c| c.action == PaletteAction::PrevTab)); assert!(COMMANDS.iter().any(|c| c.action == PaletteAction::ClearSearch)); - assert_eq!(COMMANDS.len(), 6); + assert_eq!(COMMANDS.len(), 7); } #[test] fn command_ids_are_stable() { assert_eq!(COMMANDS[0].id, "focus-search"); - assert_eq!(COMMANDS[1].id, "open-help"); - assert_eq!(COMMANDS[2].id, "next-tab"); - assert_eq!(COMMANDS[3].id, "prev-tab"); - assert_eq!(COMMANDS[4].id, "clear-search"); - assert_eq!(COMMANDS[5].id, "toggle-theme"); + assert_eq!(COMMANDS[1].id, "open-settings"); + assert_eq!(COMMANDS[2].id, "open-help"); + assert_eq!(COMMANDS[3].id, "next-tab"); + assert_eq!(COMMANDS[4].id, "prev-tab"); + assert_eq!(COMMANDS[5].id, "clear-search"); + assert_eq!(COMMANDS[6].id, "toggle-theme"); } } diff --git a/crates/sl-viewer/src/corpus_cta.rs b/crates/sl-viewer/src/corpus_cta.rs index 8ed64dde..dd81c8b7 100644 --- a/crates/sl-viewer/src/corpus_cta.rs +++ b/crates/sl-viewer/src/corpus_cta.rs @@ -1,65 +1,72 @@ -//! First-run “Open corpus…” CTA — corpus file picker (web) or quick-start docs (desktop). - -/// Repo-relative quick-start doc path (HELP.md cross-link). -pub const QUICKSTART_CORPUS_DOC: &str = "docs/guides/quick-start/QUICKSTART.md"; - -/// Public quick-start URL opened when the desktop viewer cannot show a picker. -pub const QUICKSTART_URL: &str = - "https://github.com/KooshaPari/SessionLedger/blob/main/docs/guides/quick-start/QUICKSTART.md"; - -/// Stable DOM id for the hidden Forge DB file input (web). -pub const CORPUS_PICKER_INPUT_ID: &str = "sl-corpus-picker-input"; - -/// localStorage key recording the last picked Forge DB file name (web hint only). -pub const FORGE_DB_HINT_STORAGE_KEY: &str = "sl-viewer-forge-db-hint"; - -/// Install the web corpus-picker bridge and open the Forge DB file chooser. -#[cfg(feature = "web")] -pub fn trigger_open_corpus() { - use dioxus::document; - - let script = format!( - r#" - (function() {{ - const quickstart = {quickstart:?}; - if (!window.__slCorpusCtaBridge) {{ - window.__slCorpusCtaBridge = true; - let input = document.getElementById({input_id:?}); - if (!input) {{ - input = document.createElement('input'); - input.type = 'file'; - input.id = {input_id:?}; - input.accept = '.db,.sqlite,.sqlite3'; - input.style.display = 'none'; - input.setAttribute('data-testid', 'corpus-picker-input'); - input.addEventListener('change', () => {{ - const file = input.files && input.files[0]; - if (file) {{ - window.localStorage.setItem({storage_key:?}, file.name); - document.documentElement.dataset.slCorpusSelected = 'true'; - }} - }}); - document.body.appendChild(input); - }} - window.__slOpenCorpusCta = () => {{ - input.click(); - }}; - }} - if (typeof window.__slOpenCorpusCta === 'function') {{ - window.__slOpenCorpusCta(); - return; - }} - window.open(quickstart, '_blank', 'noopener,noreferrer'); - }})(); - "#, - quickstart = QUICKSTART_URL, - input_id = CORPUS_PICKER_INPUT_ID, - storage_key = FORGE_DB_HINT_STORAGE_KEY, - ); - let _ = document::eval(&script); -} - -/// Desktop builds open the quick-start runbook (no native picker in this lane). +//! First-run “Open corpus…” CTA — corpus file picker (web) or quick-start docs (desktop). +//! +//! Also exposes a `pick_corpus_folder` desktop entry point that wraps +//! `rfd::FileDialog::pick_folder` so the Raw Sessions tab can wire a +//! native macOS / Windows / Linux folder picker into its toolbar without +//! re-implementing the platform dialog glue. + +use std::path::PathBuf; + +/// Repo-relative quick-start doc path (HELP.md cross-link). +pub const QUICKSTART_CORPUS_DOC: &str = "docs/guides/quick-start/QUICKSTART.md"; + +/// Public quick-start URL opened when the desktop viewer cannot show a picker. +pub const QUICKSTART_URL: &str = + "https://github.com/KooshaPari/SessionLedger/blob/main/docs/guides/quick-start/QUICKSTART.md"; + +/// Stable DOM id for the hidden Forge DB file input (web). +pub const CORPUS_PICKER_INPUT_ID: &str = "sl-corpus-picker-input"; + +/// localStorage key recording the last picked Forge DB file name (web hint only). +pub const FORGE_DB_HINT_STORAGE_KEY: &str = "sl-viewer-forge-db-hint"; + +/// Install the web corpus-picker bridge and open the Forge DB file chooser. +#[cfg(feature = "web")] +pub fn trigger_open_corpus() { + use dioxus::document; + + let script = format!( + r#" + (function() {{ + const quickstart = {quickstart:?}; + if (!window.__slCorpusCtaBridge) {{ + window.__slCorpusCtaBridge = true; + let input = document.getElementById({input_id:?}); + if (!input) {{ + input = document.createElement('input'); + input.type = 'file'; + input.id = {input_id:?}; + input.accept = '.db,.sqlite,.sqlite3'; + input.style.display = 'none'; + input.setAttribute('data-testid', 'corpus-picker-input'); + input.addEventListener('change', () => {{ + const file = input.files && input.files[0]; + if (file) {{ + window.localStorage.setItem({storage_key:?}, file.name); + document.documentElement.dataset.slCorpusSelected = 'true'; + }} + }}); + document.body.appendChild(input); + }} + window.__slOpenCorpusCta = () => {{ + input.click(); + }}; + }} + if (typeof window.__slOpenCorpusCta === 'function') {{ + window.__slOpenCorpusCta(); + return; + }} + window.open(quickstart, '_blank', 'noopener,noreferrer'); + }})(); + "#, + quickstart = QUICKSTART_URL, + input_id = CORPUS_PICKER_INPUT_ID, + storage_key = FORGE_DB_HINT_STORAGE_KEY, + ); + let _ = document::eval(&script); +} + +/// Desktop builds open the quick-start runbook (no native picker in this lane). #[cfg(all(not(feature = "web"), feature = "desktop", not(target_arch = "wasm32")))] pub fn trigger_open_corpus() { open_quickstart_desktop(); @@ -68,37 +75,74 @@ pub fn trigger_open_corpus() { /// Headless / test builds: no-op so unit tests stay hermetic. #[cfg(not(any(feature = "web", feature = "desktop")))] pub fn trigger_open_corpus() {} - + +/// Open a native folder picker so the user can point the viewer at an +/// arbitrary corpus directory. +/// +/// Returns `Some(path)` when the user picked a folder, `None` when they +/// cancelled. Errors from the dialog backend are logged to stderr and +/// surfaced as `None` — the picker must never crash the toolbar click +/// handler. +/// +/// Only available on desktop builds. The web build doesn't expose a +/// folder picker today (browsers don't allow it without the +/// File System Access API), so this returns `None` there. Headless +/// builds also return `None` so unit tests stay hermetic. +#[cfg(all(not(feature = "web"), feature = "desktop", not(target_arch = "wasm32")))] +pub fn pick_corpus_folder() -> Option { + let result = rfd::FileDialog::new().set_title("Pick a custom corpus folder").pick_folder(); + if let Some(ref path) = result { + eprintln!("[sl-viewer] user picked corpus folder: {}", path.display()); + } + result +} + +/// Non-desktop stub for the folder picker. +#[cfg(not(all(not(feature = "web"), feature = "desktop", not(target_arch = "wasm32"))))] +pub fn pick_corpus_folder() -> Option { + None +} + #[cfg(all(not(feature = "web"), feature = "desktop", not(target_arch = "wasm32")))] fn open_quickstart_desktop() { - let url = QUICKSTART_URL; - let result = if cfg!(target_os = "windows") { - std::process::Command::new("cmd").args(["/C", "start", "", url]).spawn() - } else if cfg!(target_os = "macos") { - std::process::Command::new("open").arg(url).spawn() - } else { - std::process::Command::new("xdg-open").arg(url).spawn() - }; - if let Err(err) = result { - eprintln!( - "[sl-viewer] could not open quick-start docs ({err}); see {QUICKSTART_CORPUS_DOC}" - ); - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn quickstart_url_points_at_repo_quickstart() { - assert!(QUICKSTART_URL.contains("KooshaPari/SessionLedger")); - assert!(QUICKSTART_URL.contains("QUICKSTART.md")); - } - - #[test] - fn corpus_picker_dom_ids_are_stable() { - assert_eq!(CORPUS_PICKER_INPUT_ID, "sl-corpus-picker-input"); - assert_eq!(FORGE_DB_HINT_STORAGE_KEY, "sl-viewer-forge-db-hint"); - } -} + let url = QUICKSTART_URL; + let result = if cfg!(target_os = "windows") { + std::process::Command::new("cmd").args(["/C", "start", "", url]).spawn() + } else if cfg!(target_os = "macos") { + std::process::Command::new("open").arg(url).spawn() + } else { + std::process::Command::new("xdg-open").arg(url).spawn() + }; + if let Err(err) = result { + eprintln!( + "[sl-viewer] could not open quick-start docs ({err}); see {QUICKSTART_CORPUS_DOC}" + ); + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn quickstart_url_points_at_repo_quickstart() { + assert!(QUICKSTART_URL.contains("KooshaPari/SessionLedger")); + assert!(QUICKSTART_URL.contains("QUICKSTART.md")); + } + + #[test] + fn corpus_picker_dom_ids_are_stable() { + assert_eq!(CORPUS_PICKER_INPUT_ID, "sl-corpus-picker-input"); + assert_eq!(FORGE_DB_HINT_STORAGE_KEY, "sl-viewer-forge-db-hint"); + } + + #[test] + fn folder_picker_returns_none_in_headless_builds() { + // On `cfg(not(any(feature = "web", feature = "desktop")))` (the + // default test invocation), the picker must be a no-op rather + // than a blocking modal. On desktop/web builds this returns + // `None` only when the user cancels — which we cannot trigger + // from a unit test, so we just assert the function is callable. + let _ = pick_corpus_folder(); + } +} diff --git a/crates/sl-viewer/src/corpus_loader.rs b/crates/sl-viewer/src/corpus_loader.rs index a8bb3dc9..2f16015b 100644 --- a/crates/sl-viewer/src/corpus_loader.rs +++ b/crates/sl-viewer/src/corpus_loader.rs @@ -7,7 +7,12 @@ //! The data-layer is intentionally decoupled from Dioxus so it can be unit-tested //! without a UI runtime. +use std::path::{Path, PathBuf}; + +use serde::{Deserialize, Serialize}; use session_ledger::domain::session::Session; +#[cfg(feature = "parquet")] +use session_ledger::ports::CorpusSource; use crate::mock_data::sample_sessions; @@ -24,12 +29,70 @@ pub enum DataSource { ForgeDb(std::path::PathBuf), } -/// Load sessions from the configured source. +/// User-supplied directories to scan in addition to (or instead of) the +/// default native session stores. +/// +/// Empty `custom_paths` means "behave exactly like the legacy auto-discovery". +/// Non-empty values are layered on top of the defaults so users can keep +/// discovering their `~/.codex/sessions` etc. while also pointing the viewer +/// at, say, an archive on an external drive. +/// +/// `CustomCorpusPath` is a `Vec` rather than a single `PathBuf` so the JSON +/// shape (`{"custom_paths": [...]}`) can grow without breaking older +/// releases. The UI currently only sets one entry at a time, but the data +/// layer accepts many. +/// +/// Serialized as a JSON array of strings via [`serde`]; the type itself is +/// intentionally `pub` so other modules can own a `Signal` +/// without going through a wrapper. +#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] +pub struct CustomCorpusPath(pub Vec); + +impl CustomCorpusPath { + /// Construct from an iterator of paths. + pub fn from_paths(paths: I) -> Self + where + I: IntoIterator, + { + Self(paths.into_iter().collect()) + } + + /// Whether no custom paths are set. + #[must_use] + pub fn is_empty(&self) -> bool { + self.0.is_empty() + } + + /// Number of custom paths currently configured. + #[must_use] + pub fn len(&self) -> usize { + self.0.len() + } + + /// Iterate over the configured custom paths. + pub fn iter(&self) -> std::slice::Iter<'_, PathBuf> { + self.0.iter() + } +} + +impl From> for CustomCorpusPath { + fn from(paths: Vec) -> Self { + Self(paths) + } +} + +impl From for CustomCorpusPath { + fn from(path: PathBuf) -> Self { + Self(vec![path]) + } +} + +/// Load sessions from the configured source, **without** any custom paths. /// -/// On `Mock`: returns the hard-coded sample sessions. -/// On `ForgeDb`: opens the DB read-only, ingests all conversations, returns -/// the successfully-parsed sessions. Rows that fail decompression or JSON -/// parsing are skipped and logged to stderr rather than aborting. +/// Convenience wrapper that calls [`load_sessions_with_custom`] with an +/// empty [`CustomCorpusPath`]. Preserves the historical single-argument +/// signature for callers that don't participate in the custom-path +/// feature (visual fixtures, the `Mock` branch). /// /// # Errors /// @@ -37,38 +100,72 @@ pub enum DataSource { /// queried (e.g. file not found, not a SQLite database). Per-row failures are /// surfaced on stderr as warnings and do not cause an error return. pub fn load_sessions(source: &DataSource) -> Result, String> { + load_sessions_with_custom(source, &CustomCorpusPath::default()) +} + +/// Load sessions from the configured source, layering `custom_paths` on top +/// of the default native session stores when `source` is [`DataSource::Auto`]. +/// +/// `Mock` and `ForgeDb` sources ignore `custom_paths` — Mock by definition, +/// ForgeDb because the SQLite database is the entire corpus. +/// +/// On `Auto`: defaults plus each existing `custom_paths` directory are +/// scanned. A custom path that doesn't exist on disk is silently skipped +/// (it's a user-pickable folder that may have been deleted while the app +/// was off). +/// +/// # Errors +/// +/// See [`load_sessions`]. +pub fn load_sessions_with_custom( + source: &DataSource, + custom_paths: &CustomCorpusPath, +) -> Result, String> { match source { DataSource::Mock => Ok(sample_sessions()), - DataSource::Auto => load_discovered_sessions(), + DataSource::Auto => load_discovered_sessions_with_custom(custom_paths), #[cfg(feature = "sqlite")] DataSource::ForgeDb(path) => load_from_sqlite(path), } } -fn load_discovered_sessions() -> Result, String> { +/// Resolve the native defaults plus any custom paths into a deduplicated, +/// existing-only list of roots ready to scan. +/// +/// The custom paths come *after* the defaults so users see their own data +/// at the bottom of the corpus table rather than pushing the standard +/// Codex/Claude/Cursor entries down. De-duplication is best-effort: equal +/// paths are coalesced; `~/foo` and `/Users/me/foo` are not, by design — +/// resolving symlinks could surprise users who deliberately linked their +/// data into the defaults. +fn collect_discovery_roots(home: &Path, custom_paths: &CustomCorpusPath) -> Vec { + let mut roots: Vec = vec![ + home.join(".codex").join("sessions"), + home.join(".claude").join("projects"), + home.join(".cursor").join("projects"), + ]; + for path in &custom_paths.0 { + if !roots.iter().any(|existing| existing == path) { + roots.push(path.clone()); + } + } + roots.into_iter().filter(|path| path.is_dir()).collect() +} + +fn load_discovered_sessions_with_custom( + custom_paths: &CustomCorpusPath, +) -> Result, String> { let home = std::env::var_os("HOME") .map(std::path::PathBuf::from) .ok_or_else(|| "HOME is not set; cannot discover local sessions".to_owned())?; let mut sessions = Vec::new(); - let mut discovered_roots = 0; - discovered_roots += load_json_corpus( - &home.join(".codex").join("sessions"), - |path| session_ledger::CodexDir::new(path.to_path_buf()), - &mut sessions, - )?; - discovered_roots += load_json_corpus( - &home.join(".claude").join("projects"), - |path| session_ledger::ClaudeDir::new(path.to_path_buf()), - &mut sessions, - )?; - // Cursor stores exported conversation JSON/JSONL under its global data - // directory on macOS. Only existing roots are scanned; caches and plans - // that do not contain transcript-shaped files are ignored by the adapter. - discovered_roots += load_json_corpus( - &home.join(".cursor").join("projects"), - |path| session_ledger::CursorDir::new(path.to_path_buf()), - &mut sessions, - )?; + let mut discovered_roots = 0usize; + + // Native defaults — dispatch by directory name to pick the right adapter. + for root in collect_discovery_roots(&home, custom_paths) { + discovered_roots += load_rooted_corpus(&root, &mut sessions)?; + } + #[cfg(feature = "sqlite")] if let Some(path) = resolve_forge_db_path(&home, std::env::var_os("FORGE_DB")) { sessions.extend(load_from_sqlite(&path)?); @@ -86,6 +183,152 @@ fn load_discovered_sessions() -> Result, String> { Ok(sessions) } +/// Scan a single root using the appropriate JSON/Parquet adapter. +/// +/// Bridges the three native session stores (Codex, Claude, Cursor) with +/// the parquet subagent's work — both `.jsonl`/`.json` (today) and +/// `.parquet` (once that lane lands) live behind this single entry point. +fn load_rooted_corpus(root: &Path, sessions: &mut Vec) -> Result { + let name = root.file_name().and_then(|n| n.to_str()).unwrap_or_default(); + match name { + "sessions" => load_json_corpus( + root, + |path| session_ledger::CodexDir::new(path.to_path_buf()), + sessions, + ), + "projects" => { + // Claude projects and Cursor projects both live under `.projects` + // directories in their respective roots, but the surrounding + // directory name tells them apart at a glance. Prefer ClaudeDir + // for ~/.claude/projects; for custom roots we try Claude first + // and Cursor second — the adapters fail fast on the wrong + // schema, so wrong-adapter picks simply contribute zero rows + // and the right one wins. + let json_rows = load_json_corpus( + root, + |path| session_ledger::ClaudeDir::new(path.to_path_buf()), + sessions, + )?; + // Claude Code on newer macOS builds drops conversation history as + // `.parquet` files under the same `~/.claude/projects` tree. The + // JSONL adapter above ignores those; the parquet adapter below + // fills that gap when the `parquet` feature is enabled. + #[cfg(feature = "parquet")] + { + let parquet_rows = load_parquet_corpus(root, sessions)?; + Ok(json_rows.saturating_add(parquet_rows)) + } + #[cfg(not(feature = "parquet"))] + { + Ok(json_rows) + } + } + // Generic root (most custom-path case): try Codex first, then + // Claude, then Cursor. The first adapter that recognizes the + // shape contributes rows; the rest contribute zero and fall + // through silently. + _ => load_json_corpus( + root, + |path| session_ledger::CodexDir::new(path.to_path_buf()), + sessions, + ), + } +} + +/// Load sessions from a user-picked directory regardless of which native +/// session store it belongs to. +/// +/// Used by the custom-path picker to ingest arbitrary directories whose +/// schema the user has explicitly confirmed. Today this delegates to the +/// same JSON-based readers as the default discovery; the `.parquet` +/// branch is a forward-looking hook for the parquet ingestion lane. +pub fn load_parquet_or_json_corpus(root: &Path) -> Result, String> { + let mut sessions = Vec::new(); + load_parquet_or_json_corpus_into(root, &mut sessions)?; + Ok(sessions) +} + +/// Like [`load_parquet_or_json_corpus`] but appends into an existing buffer. +pub fn load_parquet_or_json_corpus_into( + root: &Path, + sessions: &mut Vec, +) -> Result { + if !root.is_dir() { + return Ok(0); + } + + // JSON / JSONL / JSONL.ZST — try each native adapter in order. The + // first one that recognizes the schema contributes its rows; the + // others contribute zero and fall through silently. We count the + // session rows added in each attempt and skip later adapters once + // any rows land, so we don't double-count if, say, a Codex-shaped + // transcript also happens to parse as a Claude one. + // + // Each adapter lives in its own block so the closures don't have to + // share a single concrete return type — `load_json_corpus` is generic + // over the source type, so this is the cleanest spelling. + let before = sessions.len(); + let mut attempt_before = sessions.len(); + load_json_corpus(root, |p: &Path| session_ledger::CodexDir::new(p.to_path_buf()), sessions)?; + if sessions.len() == attempt_before { + attempt_before = sessions.len(); + load_json_corpus( + root, + |p: &Path| session_ledger::ClaudeDir::new(p.to_path_buf()), + sessions, + )?; + } + if sessions.len() == attempt_before { + load_json_corpus( + root, + |p: &Path| session_ledger::CursorDir::new(p.to_path_buf()), + sessions, + )?; + } + + // Forward-looking hook: when the parquet ingestion lane lands, scan for + // `.parquet` files in `root` and append their decoded sessions here. + // Until then this branch is a no-op — the helper is shipped so the + // public surface is stable across the JSON → Parquet transition. + let parquet_files = walk_for_extension(root, "parquet"); + if !parquet_files.is_empty() { + eprintln!( + "[sl-viewer] found {} .parquet file(s) under {}; \ + Parquet ingestion is not yet wired up in this build.", + parquet_files.len(), + root.display() + ); + } + + Ok(sessions.len() - before) +} + +/// Collect every file under `root` with the given extension. +/// +/// Returns absolute paths in lexical order. Symlinks and unreadable +/// subdirectories are silently skipped so a malformed pick doesn't fail +/// the entire discovery pass. +fn walk_for_extension(root: &Path, extension: &str) -> Vec { + let mut out = Vec::new(); + let mut stack = vec![root.to_path_buf()]; + while let Some(dir) = stack.pop() { + let entries = match std::fs::read_dir(&dir) { + Ok(entries) => entries, + Err(_) => continue, + }; + for entry in entries.flatten() { + let path = entry.path(); + if path.is_dir() { + stack.push(path); + } else if path.extension().and_then(|e| e.to_str()) == Some(extension) { + out.push(path); + } + } + } + out.sort(); + out +} + /// Resolve the Forge database used by automatic discovery. /// /// An explicit `FORGE_DB` value always wins, including when it points at a @@ -128,6 +371,36 @@ where Ok(1) } +/// Scan `root` for Claude conversation `.parquet` files and append parsed +/// sessions to `sessions`. Returns 1 when the root contains at least one +/// parquet file (counts as a "discovered" root for the empty-store check), +/// 0 when the directory is missing or has no parquet files, and an error +/// only when the discovery step itself fails (e.g. unreadable directory). +#[cfg(feature = "parquet")] +fn load_parquet_corpus( + root: &std::path::Path, + sessions: &mut Vec, +) -> Result { + if !root.is_dir() { + return Ok(0); + } + let source = crate::parquet_source::ParquetCorpusSource::new(root); + let ids = source.list().map_err(|e| format!("discover parquet {}: {e}", root.display()))?; + if ids.is_empty() { + return Ok(0); + } + for id in ids { + match source.load(&id) { + Ok(session) if !session.messages.is_empty() => sessions.push(session), + Ok(_) => {} + Err(error) => { + eprintln!("[sl-viewer] skipping parquet {}:{}: {error}", root.display(), id) + } + } + } + Ok(1) +} + /// Open a Forge SQLite DB at `path` and ingest all conversations. #[cfg(feature = "sqlite")] fn load_from_sqlite(path: &std::path::Path) -> Result, String> { @@ -223,6 +496,129 @@ mod tests { assert_eq!(sessions[0].id, "claude-local-1"); } + // ── Parquet source ──────────────────────────────────────────────────────── + + /// Re-export of the fixture writer used to materialise a tiny parquet file + /// on disk for corpus-loader integration tests. The fixture matches the + /// Claude-conversation schema used by [`crate::parquet_source`]'s unit tests. + #[cfg(feature = "parquet")] + fn write_parquet_fixture( + path: &std::path::Path, + rows: &[crate::parquet_source::test_fixture::FixtureRow], + ) { + crate::parquet_source::test_fixture::write_fixture(path, rows); + } + + #[cfg(feature = "parquet")] + #[test] + fn parquet_loader_returns_one_when_root_contains_a_parquet_file() { + use crate::parquet_source::test_fixture::FixtureRow; + + let root = tempfile::tempdir().expect("temp root"); + let path = root.path().join("transcripts.parquet"); + write_parquet_fixture( + &path, + &[FixtureRow { + session_id: "parquet-session-1".into(), + role: "user".into(), + content: "hello from parquet".into(), + ts_ms: Some(1_700_000_000_000), + cwd: Some("/code/parquet".into()), + title: Some("Parquet session".into()), + }], + ); + + let mut sessions = Vec::new(); + let roots = load_parquet_corpus(root.path(), &mut sessions).expect("parquet discover"); + + assert_eq!(roots, 1); + assert_eq!(sessions.len(), 1); + assert_eq!(sessions[0].id, "parquet-session-1"); + assert_eq!(sessions[0].corpus, session_ledger::domain::session::Corpus::ClaudeCode); + assert_eq!(sessions[0].messages.len(), 1); + assert_eq!(sessions[0].messages[0].content, "hello from parquet"); + assert_eq!(sessions[0].messages[0].ts_ms, Some(1_700_000_000_000)); + } + + #[cfg(feature = "parquet")] + #[test] + fn parquet_loader_returns_zero_when_root_has_no_parquet_files() { + let root = tempfile::tempdir().expect("temp root"); + std::fs::write(root.path().join("README.md"), b"no parquet here").expect("write file"); + + let mut sessions = Vec::new(); + let roots = load_parquet_corpus(root.path(), &mut sessions).expect("parquet discover"); + assert_eq!(roots, 0); + assert!(sessions.is_empty()); + } + + #[cfg(feature = "parquet")] + #[test] + fn parquet_loader_returns_zero_for_missing_root() { + let root = tempfile::tempdir().expect("temp root"); + let mut sessions = Vec::new(); + let roots = + load_parquet_corpus(&root.path().join("does-not-exist"), &mut sessions).expect("ok"); + assert_eq!(roots, 0); + assert!(sessions.is_empty()); + } + + #[cfg(feature = "parquet")] + #[test] + fn jsonl_and_parquet_loaders_coexist_on_claude_projects_root() { + use crate::parquet_source::test_fixture::FixtureRow; + + // Both loaders scan the same `~/.claude/projects` tree; the JSONL + // adapter should ignore parquet files and vice-versa, so two + // physically-distinct sessions — one JSONL, one parquet — both survive. + let root = tempfile::tempdir().expect("temp root"); + let project = root.path().join("-Users-demo-parquet"); + std::fs::create_dir_all(&project).expect("project root"); + + std::fs::write( + project.join("session.jsonl"), + serde_json::json!({ + "type": "user", + "sessionId": "jsonl-session-1", + "message": {"role": "user", "content": "hello from jsonl"} + }) + .to_string(), + ) + .expect("write jsonl"); + write_parquet_fixture( + &project.join("session.parquet"), + &[FixtureRow { + session_id: "parquet-session-2".into(), + role: "user".into(), + content: "hello from parquet".into(), + ts_ms: Some(1_700_000_000_000), + cwd: Some("/code/parquet".into()), + title: None, + }], + ); + + // JSONL loader sees only the JSONL file. + let mut jsonl_sessions = Vec::new(); + let jsonl_roots = load_json_corpus( + root.path(), + |path| session_ledger::ClaudeDir::new(path.to_path_buf()), + &mut jsonl_sessions, + ) + .expect("jsonl discover"); + assert_eq!(jsonl_roots, 1); + assert_eq!(jsonl_sessions.len(), 1); + assert_eq!(jsonl_sessions[0].id, "jsonl-session-1"); + + // Parquet loader sees only the parquet file. + let mut parquet_sessions = Vec::new(); + let parquet_roots = + load_parquet_corpus(root.path(), &mut parquet_sessions).expect("parquet discover"); + assert_eq!(parquet_roots, 1); + assert_eq!(parquet_sessions.len(), 1); + assert_eq!(parquet_sessions[0].id, "parquet-session-2"); + assert_eq!(parquet_sessions[0].messages[0].content, "hello from parquet"); + } + #[cfg(feature = "sqlite")] #[test] fn forge_auto_resolution_prefers_explicit_override() { @@ -460,4 +856,158 @@ mod tests { assert_eq!(s2.messages.len(), 3); } } + + // ── Custom corpus path ──────────────────────────────────────────────────── + + /// Build a Claude-shaped transcript file under `project_dir/`. + fn write_claude_project(project_dir: &std::path::Path, session_id: &str, body: &str) { + std::fs::create_dir_all(project_dir).expect("project dir"); + std::fs::write( + project_dir.join("session.jsonl"), + format!( + "{}\n", + serde_json::json!({ + "type": "user", + "sessionId": session_id, + "message": {"role": "user", "content": body} + }) + ), + ) + .expect("write transcript"); + } + + #[test] + fn custom_corpus_path_default_is_empty() { + let custom = CustomCorpusPath::default(); + assert!(custom.is_empty()); + assert_eq!(custom.len(), 0); + assert_eq!(custom.iter().count(), 0); + } + + #[test] + fn custom_corpus_path_from_single_path() { + let custom: CustomCorpusPath = PathBuf::from("/tmp/foo").into(); + assert_eq!(custom.len(), 1); + assert_eq!(custom.iter().next().expect("one"), &PathBuf::from("/tmp/foo")); + } + + #[test] + fn custom_corpus_path_from_many_paths() { + let custom = + CustomCorpusPath::from_paths(vec![PathBuf::from("/tmp/a"), PathBuf::from("/tmp/b")]); + assert_eq!(custom.len(), 2); + assert!(!custom.is_empty()); + } + + #[test] + fn custom_corpus_path_serializes_as_json_array() { + let custom = + CustomCorpusPath::from_paths(vec![PathBuf::from("/tmp/a"), PathBuf::from("/tmp/b")]); + let json = serde_json::to_string(&custom).expect("serialize"); + // The on-disk shape is a bare array of strings, which the + // CorpusPathConfig wraps under {"custom_paths": ...}. + assert_eq!(json, r#"["/tmp/a","/tmp/b"]"#); + } + + #[test] + fn custom_corpus_path_deserializes_from_json_array() { + let custom: CustomCorpusPath = + serde_json::from_str(r#"["/tmp/x","/tmp/y"]"#).expect("deserialize"); + assert_eq!(custom.len(), 2); + assert_eq!(custom.iter().next().expect("first"), &PathBuf::from("/tmp/x")); + } + + #[test] + fn load_parquet_or_json_corpus_returns_zero_for_missing_dir() { + let root = tempfile::tempdir().expect("tempdir"); + let bogus = root.path().join("does-not-exist"); + let sessions = load_parquet_or_json_corpus(&bogus).expect("missing dir"); + assert!(sessions.is_empty()); + } + + #[test] + fn load_parquet_or_json_corpus_reads_claude_shaped_root() { + let root = tempfile::tempdir().expect("tempdir"); + let project = root.path().join("-Users-foo-bar"); + write_claude_project(&project, "custom-path-1", "hello from a custom corpus"); + + let sessions = load_parquet_or_json_corpus(root.path()).expect("custom path load"); + assert_eq!(sessions.len(), 1, "should pick up the Claude-shaped transcript"); + assert_eq!(sessions[0].id, "custom-path-1"); + assert_eq!(sessions[0].messages.len(), 1); + assert_eq!(sessions[0].messages[0].content, "hello from a custom corpus"); + } + + #[test] + fn load_parquet_or_json_corpus_handles_empty_directory() { + let root = tempfile::tempdir().expect("tempdir"); + let sessions = load_parquet_or_json_corpus(root.path()).expect("empty dir"); + assert!(sessions.is_empty(), "empty directory yields no sessions"); + } + + #[test] + fn load_sessions_with_custom_layers_custom_paths_onto_defaults() { + // Custom path isolated from $HOME so the test doesn't depend on + // which session stores happen to be installed on the runner. + let prev_home = std::env::var_os("HOME"); + let fake_home = tempfile::tempdir().expect("home"); + std::env::set_var("HOME", fake_home.path()); + + let custom_root = tempfile::tempdir().expect("custom root"); + let project = custom_root.path().join("-Users-custom-repo"); + write_claude_project(&project, "layered-1", "first message"); + + let custom = CustomCorpusPath::from_paths(vec![custom_root.path().to_path_buf()]); + + let sessions = + load_sessions_with_custom(&DataSource::Auto, &custom).expect("auto + custom load"); + + // The custom path should contribute exactly one session. + let custom_count = sessions.iter().filter(|s| s.id == "layered-1").count(); + assert_eq!(custom_count, 1, "custom path must contribute its session"); + + match prev_home { + Some(value) => std::env::set_var("HOME", value), + None => std::env::remove_var("HOME"), + } + } + + #[test] + fn load_sessions_with_custom_skips_missing_custom_paths() { + let prev_home = std::env::var_os("HOME"); + let fake_home = tempfile::tempdir().expect("home"); + std::env::set_var("HOME", fake_home.path()); + + let custom = + CustomCorpusPath::from_paths(vec![PathBuf::from("/tmp/does-not-exist-anywhere")]); + + // With no defaults and a non-existent custom path, discovery must + // surface a clear error rather than panic or silently succeed. + let result = load_sessions_with_custom(&DataSource::Auto, &custom); + assert!(result.is_err(), "missing custom path + no defaults must error"); + + match prev_home { + Some(value) => std::env::set_var("HOME", value), + None => std::env::remove_var("HOME"), + } + } + + #[test] + fn walk_for_extension_collects_only_matching_files() { + let root = tempfile::tempdir().expect("tempdir"); + std::fs::write(root.path().join("a.parquet"), b"x").expect("a"); + std::fs::write(root.path().join("b.jsonl"), b"x").expect("b"); + std::fs::create_dir(root.path().join("nested")).expect("nested"); + std::fs::write(root.path().join("nested").join("c.parquet"), b"x").expect("c"); + std::fs::write(root.path().join("nested").join("d.txt"), b"x").expect("d"); + + let files = walk_for_extension(root.path(), "parquet"); + assert_eq!(files.len(), 2); + for path in &files { + assert_eq!(path.extension().and_then(|e| e.to_str()), Some("parquet")); + } + // Sorted lexically. + assert!(files[0].to_string_lossy().ends_with("a.parquet")); + assert!(files[1].to_string_lossy().ends_with("nested/c.parquet")); + } } diff --git a/crates/sl-viewer/src/corpus_paths.rs b/crates/sl-viewer/src/corpus_paths.rs new file mode 100644 index 00000000..81229410 --- /dev/null +++ b/crates/sl-viewer/src/corpus_paths.rs @@ -0,0 +1,243 @@ +//! Persistent configuration for the viewer's custom corpus paths. +//! +//! The viewer ships with a fixed set of well-known local session roots +//! (`~/.codex/sessions`, `~/.claude/projects`, `~/.cursor/projects`). Users +//! who keep their data elsewhere need a way to point the viewer at their +//! own directory; this module owns the on-disk representation of those +//! user-chosen paths. +//! +//! ## Storage location +//! +//! Paths are stored as JSON inside the platform's user config directory: +//! +//! | Platform | Path | +//! |----------|------| +//! | macOS | `~/Library/Application Support/SessionLedger/corpus_paths.json` | +//! | Linux | `${XDG_CONFIG_HOME:-~/.config}/SessionLedger/corpus_paths.json` | +//! | Windows | `%APPDATA%\SessionLedger\corpus_paths.json` | +//! +//! The location is resolved by [`dirs::config_dir`]; if that fails (sandbox +//! or unusual configuration) we fall back to the current working directory +//! so the user is never locked out of saving their picks. +//! +//! ## File format +//! +//! ```json +//! { +//! "custom_paths": ["/Users/me/code/sessions", "/tmp/legacy-codex"] +//! } +//! ``` +//! +//! The schema is intentionally tiny: a single `custom_paths` array. The +//! viewer reads it on startup, layers the entries on top of the default +//! native discovery, and rewrites the file whenever the user picks a new +//! folder or clears the override. + +use std::fs; +use std::io; +use std::path::{Path, PathBuf}; + +use serde::{Deserialize, Serialize}; + +/// Subdirectory under `dirs::config_dir()` that owns SessionLedger's state. +const CONFIG_SUBDIR: &str = "SessionLedger"; + +/// File name for the persisted corpus paths. +const CONFIG_FILE: &str = "corpus_paths.json"; + +/// On-disk shape of the corpus-paths config file. +/// +/// Only fields with `#[serde(default)]` are guaranteed to survive a downgrade +/// or hand-edit — newer viewers add fields with that attribute so older +/// builds keep parsing the file instead of blowing up. +#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] +pub struct CorpusPathConfig { + /// User-supplied directories to scan in addition to (or instead of) the + /// native session stores. May be empty. + #[serde(default)] + pub custom_paths: Vec, +} + +impl CorpusPathConfig { + /// Build an empty config (no custom paths). + #[must_use] + pub fn empty() -> Self { + Self::default() + } + + /// Whether the config has any custom paths set. + #[must_use] + pub fn is_empty(&self) -> bool { + self.custom_paths.is_empty() + } +} + +/// Resolve the absolute path of the corpus-paths config file. +/// +/// Returns `None` only when neither `dirs::config_dir()` nor the current +/// working directory can be resolved — which should never happen for a +/// desktop binary, but the `Option` keeps callers honest. +#[must_use] +pub fn default_config_path() -> Option { + if let Some(base) = dirs::config_dir() { + return Some(base.join(CONFIG_SUBDIR).join(CONFIG_FILE)); + } + std::env::current_dir().ok().map(|cwd| cwd.join(CONFIG_FILE)) +} + +/// Load the corpus-paths config from disk. +/// +/// Missing files and unreadable files both yield an empty config rather than +/// an error — the viewer's first launch on a new machine shouldn't fail just +/// because the user hasn't picked anything yet. Files that *exist* but are +/// not valid JSON surface an error so the user knows to repair or delete the +/// file rather than silently losing their picks. +/// +/// # Errors +/// +/// Returns `Err` only when the file exists but cannot be parsed as JSON. +/// Returns `Ok(CorpusPathConfig::default())` when the file is missing. +pub fn load_config() -> Result { + let Some(path) = default_config_path() else { + return Ok(CorpusPathConfig::default()); + }; + load_config_from(&path) +} + +/// Load the corpus-paths config from `path`. +/// +/// Visible for tests; production callers should use [`load_config`]. +/// Missing files yield an empty config; parse errors are returned. +pub fn load_config_from(path: &Path) -> Result { + let raw = match fs::read_to_string(path) { + Ok(s) => s, + Err(err) if err.kind() == io::ErrorKind::NotFound => { + return Ok(CorpusPathConfig::default()); + } + Err(err) => { + return Err(format!("could not read corpus paths config at {}: {err}", path.display())); + } + }; + serde_json::from_str(&raw) + .map_err(|err| format!("could not parse corpus paths config at {}: {err}", path.display())) +} + +/// Persist the corpus-paths config to disk. +/// +/// Writes the config to [`default_config_path`] and ensures the parent +/// directory exists. Overwrites any existing file. Returns the path the +/// config was written to on success so callers can surface it in the UI. +/// +/// # Errors +/// +/// Returns `Err` when the config directory cannot be created, when +/// serialization fails, or when the write itself fails. +pub fn save_config(config: &CorpusPathConfig) -> Result { + let path = default_config_path() + .ok_or_else(|| "could not resolve a config directory for SessionLedger".to_owned())?; + save_config_to(config, &path)?; + Ok(path) +} + +/// Persist the corpus-paths config to `path`. Visible for tests. +pub fn save_config_to(config: &CorpusPathConfig, path: &Path) -> Result<(), String> { + if let Some(parent) = path.parent() { + fs::create_dir_all(parent).map_err(|err| { + format!("could not create config directory {}: {err}", parent.display()) + })?; + } + let serialized = serde_json::to_string_pretty(config) + .map_err(|err| format!("could not serialize corpus paths config: {err}"))?; + fs::write(path, serialized).map_err(|err| { + format!("could not write corpus paths config to {}: {err}", path.display()) + })?; + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::collections::HashSet; + + fn sample_config() -> CorpusPathConfig { + CorpusPathConfig { + custom_paths: vec![ + PathBuf::from("/Users/me/code/sessions"), + PathBuf::from("/tmp/legacy-codex"), + ], + } + } + + #[test] + fn round_trip_write_then_read_yields_equal_config() { + let dir = tempfile::tempdir().expect("tempdir"); + let path = dir.path().join(CONFIG_FILE); + let original = sample_config(); + + save_config_to(&original, &path).expect("save"); + let restored = load_config_from(&path).expect("load"); + + assert_eq!(restored, original); + } + + #[test] + fn empty_config_round_trips() { + let dir = tempfile::tempdir().expect("tempdir"); + let path = dir.path().join(CONFIG_FILE); + let original = CorpusPathConfig::empty(); + + save_config_to(&original, &path).expect("save empty"); + let restored = load_config_from(&path).expect("load empty"); + + assert!(restored.is_empty()); + assert_eq!(restored, original); + } + + #[test] + fn missing_file_yields_empty_config() { + let dir = tempfile::tempdir().expect("tempdir"); + let path = dir.path().join("does-not-exist.json"); + let config = load_config_from(&path).expect("missing file load"); + assert!(config.is_empty()); + } + + #[test] + fn parse_error_is_surfaced() { + let dir = tempfile::tempdir().expect("tempdir"); + let path = dir.path().join(CONFIG_FILE); + fs::write(&path, "not json at all").expect("write junk"); + let result = load_config_from(&path); + assert!(result.is_err(), "junk JSON must surface as an error"); + } + + #[test] + fn save_creates_parent_directories() { + let dir = tempfile::tempdir().expect("tempdir"); + let nested = dir.path().join("a").join("b").join("c").join(CONFIG_FILE); + assert!(!nested.parent().expect("parent").exists()); + + save_config_to(&sample_config(), &nested).expect("save nested"); + + assert!(nested.exists()); + } + + #[test] + fn config_equality_ignores_path_order_independently() { + let mut a = sample_config(); + let mut b = sample_config(); + a.custom_paths.reverse(); + b.custom_paths = b.custom_paths.into_iter().collect::>().into_iter().collect(); + // Equality is order-sensitive by design, but both lists should at + // least contain the same unique entries. + let set_a: HashSet<_> = a.custom_paths.iter().collect(); + let set_b: HashSet<_> = b.custom_paths.iter().collect(); + assert_eq!(set_a, set_b); + } + + #[test] + fn empty_helper_returns_empty_config() { + let config = CorpusPathConfig::empty(); + assert!(config.is_empty()); + assert_eq!(config.custom_paths.len(), 0); + } +} diff --git a/crates/sl-viewer/src/corpus_tab.rs b/crates/sl-viewer/src/corpus_tab.rs index fe4b0162..97737ebb 100644 --- a/crates/sl-viewer/src/corpus_tab.rs +++ b/crates/sl-viewer/src/corpus_tab.rs @@ -2,16 +2,21 @@ //! tab derives from, so users can see exactly what corpus discovery found //! and reload discovery on demand. //! -//! This is the closest the viewer comes to a "feed it data myself" affordance -//! for the local session corpora. A future revision will add a custom-path -//! picker that points [`corpus_loader::load_sessions`] at a directory the -//! user chooses (FR-RAW-2). For now the tab re-runs the same Auto discovery -//! the app already uses, with a Reload button to refresh. +//! The toolbar holds three controls: +//! - **Reload discovery** — re-runs the existing Auto discovery with no +//! overrides. +//! - **Pick folder…** — opens a native folder picker; the picked path is +//! persisted to the platform config directory and added to the next +//! discovery pass in addition to the defaults. +//! - **Reset to default** — appears whenever a custom path is set; clicking +//! clears the persisted override and reverts to native-only discovery. use dioxus::prelude::*; use session_ledger::domain::session::{Corpus, Session}; -use crate::app::{DiscoveryState, ReloadTrigger, SessionContext}; +use crate::app::{CustomCorpusPaths, DiscoveryState, ReloadTrigger, SessionContext}; +use crate::corpus_cta::pick_corpus_folder; +use crate::corpus_loader::CustomCorpusPath; /// Stable, human-readable label for a [`Corpus`]. fn corpus_label(corpus: Corpus) -> &'static str { @@ -77,6 +82,12 @@ pub fn CorpusTab() -> Element { let ctx = use_context::(); let discovery = use_context::(); let mut reload = use_context::(); + let custom_paths = use_context::(); + // Clone the context wrapper once per button so each `move` closure + // owns its own copy — Dioxus `onclick` handlers are `FnOnce + Send` + // and we have three of them touching the same context. + let mut custom_paths_pick = custom_paths.clone(); + let mut custom_paths_reset = custom_paths.clone(); // Reactive read: rebuilt on every render that sees a sessions signal // change (or a manual Reload click). Sorted newest-first so the user @@ -90,6 +101,10 @@ pub fn CorpusTab() -> Element { let loading = discovery.loading.cloned(); let load_error = discovery.error.cloned(); + let current_custom_paths = custom_paths.snapshot(); + let custom_paths_display: Vec = + current_custom_paths.iter().map(|path| path.display().to_string()).collect(); + rsx! { style { r#" .corpus-view {{ @@ -105,6 +120,7 @@ pub fn CorpusTab() -> Element { padding: var(--sl-space-md) var(--sl-space-xl); border-bottom: 1px solid var(--sl-border); background: var(--sl-surface-muted); + flex-wrap: wrap; }} .corpus-title {{ font-family: var(--font-ui); @@ -132,8 +148,15 @@ pub fn CorpusTab() -> Element { background: color-mix(in srgb, var(--sl-accent) 14%, transparent); color: var(--sl-accent); }} - .corpus-reload-btn {{ + .corpus-toolbar-actions {{ margin-left: auto; + display: flex; + gap: var(--sl-space-sm); + flex-wrap: wrap; + }} + .corpus-reload-btn, + .corpus-pick-btn, + .corpus-reset-btn {{ padding: 6px 14px; font-size: 12px; font-weight: 600; @@ -143,10 +166,40 @@ pub fn CorpusTab() -> Element { color: var(--sl-text); cursor: pointer; }} - .corpus-reload-btn:hover {{ + .corpus-reload-btn:hover, + .corpus-pick-btn:hover, + .corpus-reset-btn:hover {{ border-color: var(--sl-accent); color: var(--sl-accent); }} + .corpus-pick-btn:focus-visible, + .corpus-reload-btn:focus-visible, + .corpus-reset-btn:focus-visible {{ + outline: 2px solid var(--sl-accent); + outline-offset: 2px; + }} + .corpus-reset-btn {{ + border-color: color-mix(in srgb, var(--sl-danger) 40%, var(--sl-border)); + color: var(--sl-danger); + }} + .corpus-reset-btn:hover {{ + border-color: var(--sl-danger); + color: var(--sl-danger); + }} + .corpus-custom-paths {{ + flex-basis: 100%; + font-family: var(--font-mono); + font-size: 11px; + color: var(--sl-text-muted); + padding: 4px 0; + word-break: break-all; + }} + .corpus-custom-paths-label {{ + font-family: var(--font-ui); + font-weight: 600; + color: var(--sl-accent); + margin-right: 6px; + }} .corpus-list {{ flex: 1; overflow-y: auto; @@ -226,12 +279,67 @@ pub fn CorpusTab() -> Element { } } } - button { - class: "corpus-reload-btn", - r#type: "button", - "data-testid": "corpus-reload", - onclick: move |_| reload.0.with_mut(|t| *t += 1), - "Reload discovery" + div { + class: "corpus-toolbar-actions", + button { + class: "corpus-pick-btn", + r#type: "button", + "data-testid": "corpus-pick", + title: "Pick a folder to scan in addition to the default session stores", + onclick: move |_| { + // Snapshot the latest value at click time so a + // second pick in the same session sees the + // first pick rather than the stale render-time + // copy captured by this closure. + let mut next = custom_paths_pick.snapshot(); + if let Some(path) = pick_corpus_folder() { + let path_str = path.display().to_string(); + next.0.retain(|existing| existing.display().to_string() != path_str); + next.0.push(path); + persist_custom_corpus_paths(&next); + custom_paths_pick.set(next); + reload.0.with_mut(|t| *t += 1); + } + }, + "Pick folder…" + } + button { + class: "corpus-reload-btn", + r#type: "button", + "data-testid": "corpus-reload", + onclick: move |_| reload.0.with_mut(|t| *t += 1), + "Reload discovery" + } + if !current_custom_paths.is_empty() { + button { + class: "corpus-reset-btn", + r#type: "button", + "data-testid": "corpus-reset", + title: "Clear the custom folder override and use only the default session stores", + onclick: move |_| { + custom_paths_reset.clear(); + persist_custom_corpus_paths(&CustomCorpusPath::default()); + reload.0.with_mut(|t| *t += 1); + }, + "Reset to default" + } + } + } + if !custom_paths_display.is_empty() { + div { + class: "corpus-custom-paths", + "data-testid": "corpus-custom-paths", + span { + class: "corpus-custom-paths-label", + "Custom corpus path:" + } + for (idx, path) in custom_paths_display.iter().enumerate() { + if idx > 0 { + span { " · " } + } + span { "{path}" } + } + } } } if sessions_sorted.is_empty() { @@ -245,13 +353,13 @@ pub fn CorpusTab() -> Element { div { class: "corpus-empty", role: "status", - "Discovering local session corpus… (Codex + Claude + Cursor)" + "Discovering local session corpus… (Codex + Claude + Cursor + custom)" } } else { div { class: "corpus-empty", role: "status", - "No sessions loaded yet. Reload discovery or check that one of $HOME/.codex/sessions, $HOME/.claude/projects, $HOME/.cursor/projects exists." + "No sessions loaded yet. Reload discovery, pick a custom folder, or check that one of $HOME/.codex/sessions, $HOME/.claude/projects, $HOME/.cursor/projects exists." } } } else { @@ -267,6 +375,20 @@ pub fn CorpusTab() -> Element { } } +/// Persist the current custom-paths selection to the platform config dir. +/// +/// Thin wrapper around [`crate::corpus_paths::save_config`] so the +/// `onclick` handler above can stay declarative. Logs to stderr on error +/// (the user is already looking at the toolbar; the picker must never +/// crash the click handler). +fn persist_custom_corpus_paths(paths: &CustomCorpusPath) { + use crate::corpus_paths::CorpusPathConfig; + let config = CorpusPathConfig { custom_paths: paths.0.clone() }; + if let Err(error) = crate::corpus_paths::save_config(&config) { + eprintln!("[sl-viewer] could not persist custom corpus path: {error}"); + } +} + /// One row of the corpus table — corpus, id, title, message count, last activity. #[component] fn CorpusRow(session: Session) -> Element { diff --git a/crates/sl-viewer/src/fixture.rs b/crates/sl-viewer/src/fixture.rs index 7cf6fccd..9dd2f91b 100644 --- a/crates/sl-viewer/src/fixture.rs +++ b/crates/sl-viewer/src/fixture.rs @@ -5,17 +5,11 @@ pub fn query_fixture_name() -> Option { #[cfg(feature = "web")] { - let window = match web_sys::window() { - Some(window) => window, - None => return None, - }; + let window = web_sys::window()?; let location = window.location(); let search = location.search().unwrap_or_default(); - let params = match web_sys::UrlSearchParams::new_with_str(&search) { - Ok(params) => params, - Err(_) => return None, - }; - return params.get("fixture").filter(|value| !value.trim().is_empty()); + let params = web_sys::UrlSearchParams::new_with_str(&search).ok()?; + params.get("fixture").filter(|value| !value.trim().is_empty()) } #[cfg(not(feature = "web"))] diff --git a/crates/sl-viewer/src/help_overlay.rs b/crates/sl-viewer/src/help_overlay.rs index 4941b05c..d847028c 100644 --- a/crates/sl-viewer/src/help_overlay.rs +++ b/crates/sl-viewer/src/help_overlay.rs @@ -95,7 +95,7 @@ pub fn typing_focus_active() -> bool { if let Ok(html) = element.dyn_into::() { return html.is_content_editable(); } - return false; + false } #[cfg(not(feature = "web"))] { diff --git a/crates/sl-viewer/src/lib.rs b/crates/sl-viewer/src/lib.rs index fa6d477a..ccc1a56f 100644 --- a/crates/sl-viewer/src/lib.rs +++ b/crates/sl-viewer/src/lib.rs @@ -18,6 +18,7 @@ pub mod cli_help; pub mod command_palette; pub mod corpus_cta; pub mod corpus_loader; +pub mod corpus_paths; pub mod corpus_tab; pub mod daemon_url; pub mod detail_pane; @@ -26,11 +27,17 @@ pub mod help_overlay; pub mod history_tab; pub mod live_feed; pub mod memory_tab; +#[cfg(feature = "desktop")] +pub mod menu; pub mod mock_data; +#[cfg(feature = "parquet")] +pub mod parquet_source; pub mod replay_view; pub mod search_view; pub mod session_list; pub mod session_transcript; +pub mod settings; +pub mod settings_tab; pub mod theme; pub mod timeline; pub mod tokens; @@ -41,3 +48,4 @@ pub use app::App; pub use async_states::{ContentSkeleton, ErrorState, LoadingState, SkeletonLayout}; pub use corpus_loader::{load_sessions, DataSource}; pub use session_list::SessionList; +pub use settings::{DefaultTab, Settings}; diff --git a/crates/sl-viewer/src/main.rs b/crates/sl-viewer/src/main.rs index dcd4e951..6542285e 100644 --- a/crates/sl-viewer/src/main.rs +++ b/crates/sl-viewer/src/main.rs @@ -3,6 +3,8 @@ //! Desktop : `cargo run -p sl-viewer` (default feature) //! Web WASM : `dx serve --platform web -p sl-viewer` (requires `web` feature) +#[cfg(feature = "desktop")] +use sl_viewer::menu; use sl_viewer::{cli_help, App}; /// Human-readable window title — surfaced via the OS window chrome on @@ -10,7 +12,7 @@ use sl_viewer::{cli_help, App}; /// in `Dioxus.toml`). const VIEWER_TITLE: &str = "Session Ledger Viewer"; -#[cfg(feature = "desktop")] +#[cfg(any(feature = "desktop", not(feature = "web")))] fn main() { use dioxus::desktop::{Config, WindowBuilder}; @@ -29,11 +31,21 @@ fn main() { } dioxus::LaunchBuilder::desktop() - .with_cfg(Config::new().with_window(WindowBuilder::new().with_title(VIEWER_TITLE))) + .with_cfg( + Config::new() + .with_window(WindowBuilder::new().with_title(VIEWER_TITLE)) + // Custom menu bar (File / Edit / View / Window / Help) — see + // `sl_viewer::menu::build_menu` for the structure. The default + // dioxus menu only ships Edit + Window on desktop, so we + // override it to surface the viewer-specific shortcuts + // (Reload, Command Palette, Toggle Help, etc.) in the + // platform menu bar. + .with_menu(menu::build_menu()), + ) .launch(App); } -#[cfg(feature = "web")] +#[cfg(all(feature = "web", not(feature = "desktop")))] fn main() { // The web launcher reads the title from `Dioxus.toml` (see // `app_title()` in `dioxus_cli_config`); if we ever need to set it diff --git a/crates/sl-viewer/src/menu.rs b/crates/sl-viewer/src/menu.rs new file mode 100644 index 00000000..b8e23034 --- /dev/null +++ b/crates/sl-viewer/src/menu.rs @@ -0,0 +1,185 @@ +//! macOS / desktop menu bar wiring for the `sl-viewer` window. +//! +//! The menu is registered on the [`dioxus::desktop::Config`] via +//! [`Config::with_menu`] (see `main.rs`). Menu events arrive on the +//! main thread through the dioxus runtime — `App` installs a single +//! muda event handler that dispatches by [`MenuId`] to the same DOM +//! controls the keyboard shortcuts already trigger. Reusing the +//! existing onclick handlers keeps a single source of truth for state +//! transitions (palette, help, theme) and avoids duplicating effects. +//! +//! The `web` build never links muda, so this module is compiled only +//! when the `desktop` feature is on. + +#![cfg(feature = "desktop")] + +use dioxus::desktop::muda::{ + accelerator::{Accelerator, Code, Modifiers}, + Menu, MenuItem, PredefinedMenuItem, Submenu, +}; + +// --------------------------------------------------------------------------- +// Menu item identifiers +// +// Kept as `&'static str` so the event handler in `app.rs` can match on +// `event.id().0.as_str()` without depending on muda from the UI module. +// --------------------------------------------------------------------------- + +pub const ID_APP_ABOUT: &str = "sl-viewer.app.about"; +pub const ID_APP_SETTINGS: &str = "sl-viewer.app.settings"; + +pub const ID_FILE_RELOAD_DISCOVERY: &str = "sl-viewer.file.reload-discovery"; +pub const ID_FILE_SETTINGS: &str = "sl-viewer.file.settings"; + +pub const ID_EDIT_FIND: &str = "sl-viewer.edit.find"; + +pub const ID_VIEW_RELOAD: &str = "sl-viewer.view.reload"; +pub const ID_VIEW_TOGGLE_THEME: &str = "sl-viewer.view.toggle-theme"; +pub const ID_VIEW_COMMAND_PALETTE: &str = "sl-viewer.view.command-palette"; + +pub const ID_HELP_TOGGLE: &str = "sl-viewer.help.toggle"; + +// --------------------------------------------------------------------------- +// Accelerators +// +// Use `SUPER` (Cmd) on macOS so shortcuts match platform expectations. +// muda's `Accelerator` only supports the standard modifier+key combo, so +// `?` is bound as Shift+Slash. The keyboard hotkey bridge in `app.rs` +// already accepts `?` / Shift+Slash, so the menu shortcut round-trips +// to the same DOM button click. +// --------------------------------------------------------------------------- + +#[cfg(target_os = "macos")] +const META: Modifiers = Modifiers::SUPER; +#[cfg(not(target_os = "macos"))] +const META: Modifiers = Modifiers::CONTROL; + +fn acc(mods: Modifiers, key: Code) -> Accelerator { + Accelerator::new(Some(mods), key) +} + +/// Build the menu bar for the desktop window. +/// +/// `dioxus::desktop::Config::with_menu` swaps this in for the default +/// (which only ships Edit + Window). The structure follows the macOS +/// HIG: the first submenu is treated as the application menu and is +/// auto-renamed to the bundle name by AppKit, so we tag it with +/// `SessionLedger` even though AppKit rewrites it. +pub fn build_menu() -> Menu { + let menu = Menu::new(); + + // ---- Application menu (macOS only renames it to the bundle name) ----- + let app_menu = Submenu::new("SessionLedger", true); + app_menu + .append_items(&[ + &MenuItem::with_id(ID_APP_ABOUT, "About SessionLedger", true, None::), + &PredefinedMenuItem::separator(), + &MenuItem::with_id( + ID_APP_SETTINGS, + "Settings\u{2026}", + true, + Some(acc(META, Code::Comma)), + ), + &PredefinedMenuItem::separator(), + // muda wires ⌘Q on macOS / Ctrl+Q on Win/Linux automatically. + &PredefinedMenuItem::quit(Some("Quit SessionLedger")), + ]) + .expect("append app menu items"); + + // ---- File ---------------------------------------------------------------- + let file_menu = Submenu::new("File", true); + file_menu + .append_items(&[ + &MenuItem::with_id( + ID_FILE_RELOAD_DISCOVERY, + "Reload discovery", + true, + None::, + ), + &MenuItem::with_id( + ID_FILE_SETTINGS, + "Settings\u{2026}", + true, + Some(acc(META, Code::Comma)), + ), + &PredefinedMenuItem::separator(), + // The Predefined quit item already lives under the app menu on + // macOS; duplicating it under File would be redundant. + #[cfg(not(target_os = "macos"))] + &PredefinedMenuItem::quit(Some("Quit")), + ]) + .expect("append file menu items"); + + // ---- Edit ---------------------------------------------------------------- + // Predefined cut/copy/paste/select-all are pre-bound to the OS shortcuts + // (⌘X/⌘C/⌘V/⌘A on macOS). We layer a "Find" item on top so the existing + // keyboard hotkey bridge in `app.rs` gets a click on the search tab + // button (the Search tab is mounted but there is no dedicated focusable + // search input today; ⌘F just routes to that tab). + let edit_menu = Submenu::new("Edit", true); + edit_menu + .append_items(&[ + &PredefinedMenuItem::undo(Some("Undo")), + &PredefinedMenuItem::redo(Some("Redo")), + &PredefinedMenuItem::separator(), + &PredefinedMenuItem::cut(Some("Cut")), + &PredefinedMenuItem::copy(Some("Copy")), + &PredefinedMenuItem::paste(Some("Paste")), + &PredefinedMenuItem::select_all(Some("Select All")), + &PredefinedMenuItem::separator(), + &MenuItem::with_id(ID_EDIT_FIND, "Find\u{2026}", true, Some(acc(META, Code::KeyF))), + ]) + .expect("append edit menu items"); + + // ---- View ---------------------------------------------------------------- + let view_menu = Submenu::new("View", true); + view_menu + .append_items(&[ + &MenuItem::with_id(ID_VIEW_RELOAD, "Reload", true, Some(acc(META, Code::KeyR))), + &MenuItem::with_id(ID_VIEW_TOGGLE_THEME, "Toggle Theme", true, None::), + &PredefinedMenuItem::separator(), + &MenuItem::with_id( + ID_VIEW_COMMAND_PALETTE, + "Open Command Palette", + true, + Some(acc(META, Code::KeyK)), + ), + ]) + .expect("append view menu items"); + + // ---- Window -------------------------------------------------------------- + // Minimize / Zoom / Fullscreen are platform-predefined so the OS owns + // their behavior (correct focus handling, AppKit integration on macOS). + let window_menu = Submenu::new("Window", true); + window_menu + .append_items(&[ + &PredefinedMenuItem::minimize(Some("Minimize")), + &PredefinedMenuItem::maximize(Some("Zoom")), + &PredefinedMenuItem::fullscreen(Some("Enter Full Screen")), + ]) + .expect("append window menu items"); + + // ---- Help ---------------------------------------------------------------- + let help_menu = Submenu::new("Help", true); + help_menu + .append_items(&[&MenuItem::with_id( + ID_HELP_TOGGLE, + "Toggle Help overlay", + true, + Some(acc(Modifiers::SHIFT, Code::Slash)), + )]) + .expect("append help menu items"); + + // Note: `set_as_help_menu_for_nsapp()` / `set_as_windows_menu_for_nsapp()` + // intentionally NOT called here — muda's contract is that those run after + // `Menu::init_for_nsapp()` (which `dioxus-desktop` calls once it has + // attached the menu to the NSApp). At build-time the submenu's `ns_menu` + // field is still `None`; calling those now would `unwrap()` and panic. + // macOS still finds the Help menu by title ("Help") per AppKit convention, + // and the Window menu is decorative for a single-window viewer. + + menu.append_items(&[&app_menu, &file_menu, &edit_menu, &view_menu, &window_menu, &help_menu]) + .expect("append top-level menus to menu bar"); + + menu +} diff --git a/crates/sl-viewer/src/parquet_source.rs b/crates/sl-viewer/src/parquet_source.rs new file mode 100644 index 00000000..80d40ef9 --- /dev/null +++ b/crates/sl-viewer/src/parquet_source.rs @@ -0,0 +1,601 @@ +//! Parquet corpus source for Claude Code conversation exports. +//! +//! Claude Code drops conversation-history files under `~/.claude/projects` as +//! either JSONL or — on newer macOS builds — Parquet. The JSONL path is +//! handled by [`crate::corpus_loader`] via [`session_ledger::ClaudeDir`]; the +//! Parquet variant was previously silently skipped, which left a real data gap +//! for any user whose install writes `.parquet` rather than `.jsonl`. +//! +//! This module wires the row-based [`parquet`] reader into the +//! [`session_ledger::ports::CorpusSource`] trait used by the viewer. It is +//! compiled only when the `parquet` cargo feature is enabled; otherwise the +//! module compiles to a no-op `cfg`-stub so the rest of the crate stays +//! untouched. +//! +//! Expected per-row schema (one row per message; column order and repetition +//! are not enforced, but the names below are recognised case-insensitively): +//! +//! | column | type | notes | +//! |---------------|----------|--------------------------------------| +//! | `session_id` | string | REQUIRED; groups rows into sessions | +//! | `role` | string | user / assistant / tool / system | +//! | `content` | string | REQUIRED; the message body | +//! | `ts_ms` | int64 | Unix milliseconds; optional | +//! | `cwd` | string | optional; first non-null wins | +//! | `title` | string | optional; first non-null wins | +//! +//! Each `.parquet` file may hold one or many sessions. A single file's rows are +//! grouped by `session_id`; the loader exposes one session per unique id. + +use std::{ + collections::BTreeMap, + fs, + path::{Path, PathBuf}, + sync::OnceLock, +}; + +use parquet::{ + file::reader::{FileReader, SerializedFileReader}, + record::{Field, Row}, +}; +use session_ledger::{ + domain::session::{Corpus, Message, Role, Session}, + ports::{CorpusSource, PortError}, +}; + +/// Parquet corpus source rooted at a `~/.claude/projects`-style directory. +/// +/// One instance per directory. The session-id → file-path index is built +/// lazily on the first call to [`CorpusSource::list`] and then reused for any +/// subsequent [`CorpusSource::load`] calls so we re-read each parquet file at +/// most twice total (once for discovery, once for hydration). +pub struct ParquetCorpusSource { + root: PathBuf, + index: OnceLock, String>>, +} + +impl ParquetCorpusSource { + /// Create a new source rooted at `root`. + /// + /// The directory does not have to exist; an empty `list()` is returned in + /// that case so the loader can silently skip the root without surfacing a + /// hard error for end users who do not have a Claude install. + #[must_use] + pub fn new(root: impl Into) -> Self { + Self { root: root.into(), index: OnceLock::new() } + } + + /// Return the root directory backing this source. + #[must_use] + pub fn root(&self) -> &Path { + &self.root + } + + /// Build (or return the cached) `session_id -> file_path` index. + fn ensure_index(&self) -> Result<&BTreeMap, PortError> { + let result = self.index.get_or_init(|| build_index(&self.root).map_err(|e| e.to_string())); + match result { + Ok(index) => Ok(index), + Err(message) => Err(PortError::Backend(message.clone())), + } + } +} + +impl CorpusSource for ParquetCorpusSource { + fn list(&self) -> Result, PortError> { + Ok(self.ensure_index()?.keys().cloned().collect()) + } + + fn load(&self, id: &str) -> Result { + let index = self.ensure_index()?; + let path = index.get(id).ok_or_else(|| PortError::NotFound(id.to_owned()))?.clone(); + load_session_from_file(&path, id) + } +} + +// ── index construction ─────────────────────────────────────────────────────── + +fn build_index(root: &Path) -> Result, ParquetSourceError> { + let mut index: BTreeMap = BTreeMap::new(); + let files = discover_parquet_files(root)?; + for path in files { + let ids = session_ids_in_file(&path)?; + for id in ids { + if let Some(prior) = index.insert(id.clone(), path.clone()) { + // Two parquet files claim the same session id — keep the first + // and surface a warning so duplicate-export noise is visible. + eprintln!( + "[sl-viewer] parquet: duplicate session id {id} across {} and {}; keeping first", + prior.display(), + path.display() + ); + } + } + } + Ok(index) +} + +fn discover_parquet_files(root: &Path) -> Result, ParquetSourceError> { + if !root.exists() { + return Ok(Vec::new()); + } + if !root.is_dir() { + return Err(ParquetSourceError::Backend(format!( + "parquet root is not a directory: {}", + root.display() + ))); + } + let mut out = Vec::new(); + collect_parquet_files(root, &mut out)?; + out.sort(); + Ok(out) +} + +fn collect_parquet_files(dir: &Path, out: &mut Vec) -> Result<(), ParquetSourceError> { + let entries = fs::read_dir(dir) + .map_err(|e| ParquetSourceError::Backend(format!("read_dir {}: {e}", dir.display())))?; + for entry in entries { + let entry = entry.map_err(|e| { + ParquetSourceError::Backend(format!("read entry in {}: {e}", dir.display())) + })?; + let path = entry.path(); + if path.is_dir() { + collect_parquet_files(&path, out)?; + } else if path.extension().and_then(|s| s.to_str()) == Some("parquet") { + out.push(path); + } + } + Ok(()) +} + +/// Read every row in `path` and collect the distinct session ids it contains. +/// +/// A missing or unreadable file is reported as a backend error so the caller +/// can decide whether to skip it (loader path) or fail (test path). +fn session_ids_in_file(path: &Path) -> Result, ParquetSourceError> { + let file = fs::File::open(path) + .map_err(|e| ParquetSourceError::Backend(format!("open {}: {e}", path.display())))?; + let reader = SerializedFileReader::new(file).map_err(|e| { + ParquetSourceError::Backend(format!("parquet reader {}: {e}", path.display())) + })?; + let iter = reader.get_row_iter(None).map_err(|e| { + ParquetSourceError::Backend(format!("parquet iter {}: {e}", path.display())) + })?; + let mut seen: Vec = Vec::new(); + for row in iter { + let row = row.map_err(|e| { + ParquetSourceError::Backend(format!("parquet row in {}: {e}", path.display())) + })?; + if let Some(id) = + field_string_by_name(&row, &["session_id", "sessionId", "conversation_id"]) + { + if !seen.iter().any(|existing| existing == &id) { + seen.push(id); + } + } + } + Ok(seen) +} + +// ── per-file load ──────────────────────────────────────────────────────────── + +fn load_session_from_file(path: &Path, session_id: &str) -> Result { + let file = fs::File::open(path) + .map_err(|e| PortError::Backend(format!("open {}: {e}", path.display())))?; + let reader = SerializedFileReader::new(file) + .map_err(|e| PortError::Backend(format!("parquet reader {}: {e}", path.display())))?; + let iter = reader + .get_row_iter(None) + .map_err(|e| PortError::Backend(format!("parquet iter {}: {e}", path.display())))?; + + let mut session = Session::new(session_id, Corpus::ClaudeCode); + let mut cwd_seen = false; + let mut title_seen = false; + let mut messages: Vec = Vec::new(); + + for row in iter { + let row = + row.map_err(|e| PortError::Backend(format!("parquet row in {}: {e}", path.display())))?; + + // Session scoping: a file may contain rows for many sessions. Only + // rows whose session_id matches the requested id contribute messages + // (and metadata). + let row_session = + field_string_by_name(&row, &["session_id", "sessionId", "conversation_id"]); + if row_session.as_deref() != Some(session_id) { + continue; + } + + if !cwd_seen { + if let Some(cwd) = field_string_by_name(&row, &["cwd", "workingDirectory", "workspace"]) + { + session.cwd = Some(cwd); + cwd_seen = true; + } + } + if !title_seen { + if let Some(title) = field_string_by_name(&row, &["title", "name"]) { + session.title = Some(title); + title_seen = true; + } + } + + let content = match field_string_by_name(&row, &["content", "text", "message"]) { + Some(c) => c, + None => continue, + }; + let role = field_string_by_name(&row, &["role"]) + .as_deref() + .and_then(map_role) + .unwrap_or(Role::User); + let ts_ms = field_int_by_name(&row, &["ts_ms", "timestamp_ms", "timestamp"]); + messages.push(Message { role, content, ts_ms }); + } + + session.messages = messages; + Ok(session) +} + +// ── field extraction helpers ──────────────────────────────────────────────── + +fn field_string_by_name(row: &Row, candidates: &[&str]) -> Option { + for (name, field) in row.get_column_iter() { + if !candidates.iter().any(|c| name.eq_ignore_ascii_case(c)) { + continue; + } + if let Some(value) = field_to_string(field) { + return Some(value); + } + } + None +} + +fn field_int_by_name(row: &Row, candidates: &[&str]) -> Option { + for (name, field) in row.get_column_iter() { + if !candidates.iter().any(|c| name.eq_ignore_ascii_case(c)) { + continue; + } + if let Some(value) = field_to_i64(field) { + return Some(value); + } + } + None +} + +fn field_to_string(field: &Field) -> Option { + match field { + Field::Null => None, + Field::Str(s) => Some(s.clone()), + Field::Bytes(b) => Some(b.as_utf8().ok()?.to_owned()), + Field::Bool(b) => Some(b.to_string()), + Field::Int(i) => Some(i.to_string()), + Field::Long(i) => Some(i.to_string()), + Field::Float(f) => Some(f.to_string()), + Field::Double(f) => Some(f.to_string()), + Field::TimestampMillis(i) => Some(i.to_string()), + Field::TimestampMicros(i) => Some(i.to_string()), + _ => None, + } +} + +fn field_to_i64(field: &Field) -> Option { + match field { + Field::Long(i) => Some(*i), + Field::Int(i) => Some(i64::from(*i)), + Field::Short(i) => Some(i64::from(*i)), + Field::Byte(i) => Some(i64::from(*i)), + Field::UByte(i) => Some(i64::from(*i)), + Field::UShort(i) => Some(i64::from(*i)), + Field::UInt(i) => Some(i64::from(*i)), + Field::ULong(i) => i64::try_from(*i).ok(), + Field::Bool(b) => Some(i64::from(*b)), + Field::TimestampMillis(i) => Some(*i), + Field::TimestampMicros(i) => Some(*i / 1000), + Field::Str(s) => s.trim().parse::().ok(), + _ => None, + } +} + +fn map_role(value: &str) -> Option { + match value.to_ascii_lowercase().as_str() { + "user" | "human" => Some(Role::User), + "assistant" | "agent" | "claude" => Some(Role::Assistant), + "system" | "developer" => Some(Role::System), + "tool" | "tool_result" | "tool-result" | "function" => Some(Role::Tool), + "subagent" => Some(Role::Subagent), + _ => None, + } +} + +/// Errors that arise while reading parquet files in this module. +#[derive(Debug)] +enum ParquetSourceError { + /// A backend error wrapping a lower-level io / parse failure. + Backend(String), +} + +impl std::fmt::Display for ParquetSourceError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Backend(message) => f.write_str(message), + } + } +} + +impl std::error::Error for ParquetSourceError {} + +// ── tests ──────────────────────────────────────────────────────────────────── + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn list_returns_session_ids_for_every_unique_session() { + let dir = tempfile::tempdir().expect("tempdir"); + let path = dir.path().join("transcripts.parquet"); + test_fixture::write_fixture( + &path, + &[ + test_fixture::FixtureRow { + session_id: "sess-aaa".into(), + role: "user".into(), + content: "hello".into(), + ts_ms: Some(1_700_000_000_000), + cwd: Some("/repo/a".into()), + title: Some("alpha".into()), + }, + test_fixture::FixtureRow { + session_id: "sess-aaa".into(), + role: "assistant".into(), + content: "hi".into(), + ts_ms: Some(1_700_000_001_000), + cwd: None, + title: None, + }, + test_fixture::FixtureRow { + session_id: "sess-bbb".into(), + role: "user".into(), + content: "second session".into(), + ts_ms: Some(1_700_000_002_000), + cwd: Some("/repo/b".into()), + title: Some("beta".into()), + }, + ], + ); + + let source = ParquetCorpusSource::new(dir.path()); + let ids = source.list().expect("list"); + assert_eq!(ids, vec!["sess-aaa".to_owned(), "sess-bbb".to_owned()]); + } + + #[test] + fn load_returns_messages_for_a_single_session() { + let dir = tempfile::tempdir().expect("tempdir"); + let path = dir.path().join("transcripts.parquet"); + test_fixture::write_fixture( + &path, + &[ + test_fixture::FixtureRow { + session_id: "sess-aaa".into(), + role: "user".into(), + content: "hello".into(), + ts_ms: Some(1_700_000_000_000), + cwd: Some("/repo/a".into()), + title: Some("alpha".into()), + }, + test_fixture::FixtureRow { + session_id: "sess-aaa".into(), + role: "assistant".into(), + content: "hi there".into(), + ts_ms: Some(1_700_000_001_000), + cwd: None, + title: None, + }, + test_fixture::FixtureRow { + session_id: "sess-bbb".into(), + role: "user".into(), + content: "unrelated session content".into(), + ts_ms: Some(1_700_000_002_000), + cwd: Some("/repo/b".into()), + title: Some("beta".into()), + }, + ], + ); + + let source = ParquetCorpusSource::new(dir.path()); + let session = source.load("sess-aaa").expect("load session"); + assert_eq!(session.id, "sess-aaa"); + assert_eq!(session.corpus, Corpus::ClaudeCode); + assert_eq!(session.cwd.as_deref(), Some("/repo/a")); + assert_eq!(session.title.as_deref(), Some("alpha")); + assert_eq!(session.messages.len(), 2); + assert_eq!(session.messages[0].role, Role::User); + assert_eq!(session.messages[0].content, "hello"); + assert_eq!(session.messages[0].ts_ms, Some(1_700_000_000_000)); + assert_eq!(session.messages[1].role, Role::Assistant); + assert_eq!(session.messages[1].content, "hi there"); + assert_eq!(session.messages[1].ts_ms, Some(1_700_000_001_000)); + } + + #[test] + fn list_returns_empty_for_missing_directory() { + let dir = tempfile::tempdir().expect("tempdir"); + let source = ParquetCorpusSource::new(dir.path().join("does-not-exist")); + assert!(source.list().expect("list missing dir").is_empty()); + } + + #[test] + fn load_returns_not_found_for_unknown_id() { + let dir = tempfile::tempdir().expect("tempdir"); + let path = dir.path().join("transcripts.parquet"); + test_fixture::write_fixture( + &path, + &[test_fixture::FixtureRow { + session_id: "sess-aaa".into(), + role: "user".into(), + content: "hello".into(), + ts_ms: Some(1), + cwd: None, + title: None, + }], + ); + let source = ParquetCorpusSource::new(dir.path()); + let error = source.load("missing").expect_err("load should fail"); + assert!(matches!(error, PortError::NotFound(_))); + } + + #[test] + fn load_discovers_files_in_nested_project_directories() { + // Mimic the `~/.claude/projects/-Users-foo-repo/transcript.parquet` + // layout that the JSONL loader already supports. + let root = tempfile::tempdir().expect("tempdir"); + let project = root.path().join("-Users-foo-repo"); + fs::create_dir_all(&project).expect("mkdir"); + let nested = project.join("transcripts.parquet"); + test_fixture::write_fixture( + &nested, + &[ + test_fixture::FixtureRow { + session_id: "deep-session".into(), + role: "user".into(), + content: "nested hello".into(), + ts_ms: Some(42), + cwd: Some("/repo/nested".into()), + title: None, + }, + test_fixture::FixtureRow { + session_id: "deep-session".into(), + role: "assistant".into(), + content: "nested hi".into(), + ts_ms: Some(43), + cwd: None, + title: Some("nested-title".into()), + }, + ], + ); + + let source = ParquetCorpusSource::new(root.path()); + let ids = source.list().expect("list nested"); + assert_eq!(ids, vec!["deep-session".to_owned()]); + + let session = source.load("deep-session").expect("load nested"); + assert_eq!(session.messages.len(), 2); + assert_eq!(session.messages[0].content, "nested hello"); + assert_eq!(session.title.as_deref(), Some("nested-title")); + assert_eq!(session.cwd.as_deref(), Some("/repo/nested")); + } +} + +/// Test fixture helpers — public so corpus-loader integration tests in +/// `corpus_loader::tests` can materialise small parquet files without +/// duplicating the writer plumbing. Compiled only under `cfg(test)`. +#[cfg(test)] +pub mod test_fixture { + use std::{fs::File, path::Path, sync::Arc}; + + use parquet::{ + data_type::ByteArrayType, + file::{properties::WriterProperties, writer::SerializedFileWriter}, + schema::parser::parse_message_type, + }; + + /// Minimal Claude-conversation-shaped parquet schema used by the fixture + /// writers below. Column order matches the convention used in production + /// Claude exports but the reader is column-name based and does not depend + /// on order. + const CLAUDE_SCHEMA: &str = " + message claude_session { + REQUIRED BYTE_ARRAY session_id (UTF8); + REQUIRED BYTE_ARRAY role (UTF8); + REQUIRED BYTE_ARRAY content (UTF8); + OPTIONAL INT64 ts_ms; + OPTIONAL BYTE_ARRAY cwd (UTF8); + OPTIONAL BYTE_ARRAY title (UTF8); + } + "; + + /// A single row of the test fixture. Mirrors the production Claude + /// parquet row schema. + #[derive(Clone)] + pub struct FixtureRow { + pub session_id: String, + pub role: String, + pub content: String, + pub ts_ms: Option, + pub cwd: Option, + pub title: Option, + } + + fn write_string_column( + row_group: &mut parquet::file::writer::SerializedRowGroupWriter<'_, W>, + values: &[Option<&str>], + ) { + let mut writer = row_group.next_column().expect("column").expect("required column"); + // The parquet typed writer only writes `values_to_write` entries to + // the values stream, where `values_to_write` equals the count of + // `def_level == max_def_level` (i.e. non-null) entries. The values + // buffer must therefore contain *only* the non-null entries in the + // order they appear; the def-levels buffer continues to hold one + // entry per logical row so the reader can recover nulls. + let ba_values: Vec = + values.iter().filter_map(|v| v.map(parquet::data_type::ByteArray::from)).collect(); + let def_levels: Vec = values.iter().map(|v| i16::from(v.is_some())).collect(); + writer + .typed::() + .write_batch(&ba_values, Some(&def_levels), None) + .expect("write string batch"); + writer.close().expect("close string column"); + } + + fn write_int_column( + row_group: &mut parquet::file::writer::SerializedRowGroupWriter<'_, W>, + values: &[Option], + ) { + let mut writer = row_group.next_column().expect("column").expect("required column"); + // See `write_string_column` — the values stream holds only non-null + // entries in order; def-levels keep one entry per logical row. + let int_values: Vec = values.iter().filter_map(|v| *v).collect(); + let def_levels: Vec = values.iter().map(|v| i16::from(v.is_some())).collect(); + writer + .typed::() + .write_batch(&int_values, Some(&def_levels), None) + .expect("write int batch"); + writer.close().expect("close int column"); + } + + /// Write a tiny parquet fixture containing the given rows. Used by the + /// unit tests above and by the corpus-loader integration tests. + pub fn write_fixture(path: &Path, rows: &[FixtureRow]) { + let schema = Arc::new(parse_message_type(CLAUDE_SCHEMA).expect("parse schema")); + let props = Arc::new(WriterProperties::builder().build()); + let file = File::create(path).expect("create fixture"); + let mut writer = SerializedFileWriter::new(file, schema, props).expect("create writer"); + + // Column-aligned buffers. Each row contributes one entry per column. + let mut session_ids: Vec> = Vec::with_capacity(rows.len()); + let mut roles: Vec> = Vec::with_capacity(rows.len()); + let mut contents: Vec> = Vec::with_capacity(rows.len()); + let mut ts_values: Vec> = Vec::with_capacity(rows.len()); + let mut cwds: Vec> = Vec::with_capacity(rows.len()); + let mut titles: Vec> = Vec::with_capacity(rows.len()); + for row in rows { + session_ids.push(Some(row.session_id.as_str())); + roles.push(Some(row.role.as_str())); + contents.push(Some(row.content.as_str())); + ts_values.push(row.ts_ms); + cwds.push(row.cwd.as_deref()); + titles.push(row.title.as_deref()); + } + + let mut row_group = writer.next_row_group().expect("row group"); + write_string_column(&mut row_group, &session_ids); + write_string_column(&mut row_group, &roles); + write_string_column(&mut row_group, &contents); + write_int_column(&mut row_group, &ts_values); + write_string_column(&mut row_group, &cwds); + write_string_column(&mut row_group, &titles); + row_group.close().expect("close row group"); + writer.close().expect("close writer"); + } +} diff --git a/crates/sl-viewer/src/settings.rs b/crates/sl-viewer/src/settings.rs new file mode 100644 index 00000000..6d811777 --- /dev/null +++ b/crates/sl-viewer/src/settings.rs @@ -0,0 +1,459 @@ +//! Persistent user settings for the sl-viewer (FR-VIEWER-SETTINGS-1). +//! +//! Settings are stored as pretty-printed JSON at: +//! +//! - macOS: `~/Library/Application Support/SessionLedger/settings.json` +//! - Linux: `${XDG_CONFIG_HOME:-~/.config}/SessionLedger/settings.json` +//! - Windows: `%APPDATA%\SessionLedger\settings.json` +//! - WASM: no filesystem access — [`Settings::load`] returns the +//! in-memory defaults and [`Settings::save`] returns an error. +//! +//! The location can be overridden at runtime via the +//! `SL_VIEWER_SETTINGS_DIR` environment variable (used by the test suite). +//! +//! All I/O is best-effort: a corrupt or unreadable file silently falls back +//! to [`Settings::default`] so a malformed preferences file can never brick +//! the viewer. + +use std::fs; +use std::path::{Path, PathBuf}; + +use serde::{Deserialize, Serialize}; + +use crate::theme::Theme; + +/// Stable, serde-friendly enumeration of the tab the viewer should land on +/// at launch. +/// +/// Mirrors the runtime [`crate::app::Tab`] enum without depending on it +/// (`app.rs` imports this enum to seed the initial `use_signal`). Keeping +/// the mirror in a dedicated module avoids a `settings -> app -> settings` +/// cycle. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)] +#[serde(rename_all = "kebab-case")] +pub enum DefaultTab { + #[default] + Bundles, + History, + Unfinished, + Memory, + LiveFeed, + Search, + Timeline, + Replay, + Corpus, +} + +impl DefaultTab { + /// All variants, in tab-bar order (matches [`crate::app::Tab::ALL`] + /// minus the Settings tab, which we never auto-launch into). + pub const ALL: [DefaultTab; 9] = [ + DefaultTab::Bundles, + DefaultTab::History, + DefaultTab::Unfinished, + DefaultTab::Memory, + DefaultTab::LiveFeed, + DefaultTab::Search, + DefaultTab::Timeline, + DefaultTab::Replay, + DefaultTab::Corpus, + ]; + + /// Human-readable label for `