diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..30defc5 --- /dev/null +++ b/src/main.rs @@ -0,0 +1,800 @@ +mod document; +mod preview; +mod provider; + +use document::Answers; +use gpui_kit::component::Root; +use gpui_kit::component::input::{ + Editor, EditorState, Input, InputEvent, InputState, TextDecoration, TextDecorationCollection, +}; +use gpui_kit::component::text::{TextView, TextViewState, TextViewStyle}; +use gpui_kit::prelude::FluentBuilder; +use gpui_kit::*; +use std::{ + collections::HashMap, + fs, + io::Write, + path::PathBuf, + process::{Command, Stdio}, +}; + +const BG: u32 = 0xf3f0e9; +const PAPER: u32 = 0xfffdf8; +const EDGE: u32 = 0xd9d5cd; +const TEXT: u32 = 0x262521; +const MUTED: u32 = 0x77736d; +const ACCENT: u32 = 0x85603c; + +#[derive(Clone, Copy, PartialEq)] +enum Mode { + Normal, + Insert, + Visual, + Command, +} + +#[derive(Clone, Copy, PartialEq)] +enum Provider { + Codex, + OpenRouter, +} + +struct Vool { + editor: Entity, + preview_view: Entity, + previewing: bool, + preview_seq: u64, + answer_styles: TextDecorationCollection, + command: Entity, + mode: Mode, + anchor: usize, + visual_head: usize, + path: PathBuf, + notes_dir: PathBuf, + saved_text: String, + answers: Answers, + model: String, + provider: Provider, + status: String, + pending: HashMap, + request_seq: u64, + _subscription: Subscription, +} + +impl Vool { + fn sidecar(&self) -> PathBuf { + self.path.with_extension("vool.json") + } + + fn files(dir: &PathBuf) -> Vec { + let mut files: Vec<_> = fs::read_dir(dir) + .into_iter() + .flatten() + .flatten() + .map(|entry| entry.path()) + .filter(|p| p.extension().is_some_and(|e| e == "md")) + .collect(); + files.sort(); + files + } + + fn new(window: &mut Window, cx: &mut Context) -> Self { + let notes_dir = std::env::current_dir().unwrap().join("notes"); + fs::create_dir_all(¬es_dir).expect("create notes directory"); + let path = Self::files(¬es_dir) + .first() + .cloned() + .unwrap_or_else(|| notes_dir.join("Welcome.md")); + let saved_text = fs::read_to_string(&path).unwrap_or_else(|_| String::from( + "# A place to follow your curiosity\n\nWrite a question here. Press Esc, move with h/j/k/l, then v to select a thought. Press a to ask.\n\nAnswers appear immediately after the question. Press p to read rendered Markdown.\n" + )); + let answers = Answers::load(&path.with_extension("vool.json")); + let editor = cx.new(|cx| { + EditorState::new(window, cx) + .line_number(false) + .soft_wrap(true) + .default_value(saved_text.clone()) + }); + let preview_view = cx.new(|cx| TextViewState::markdown(&saved_text, cx)); + editor.update(cx, |state, cx| state.set_readonly(true, cx)); + let answer_styles = editor.update(cx, |state, cx| { + state.create_decorations_collection(Self::answer_decorations(&answers, &saved_text), cx) + }); + let command = + cx.new(|cx| InputState::new(window, cx).placeholder("new, open, files, w, model")); + let _subscription = cx.subscribe(&editor, |this, _, event, cx| { + if matches!(event, InputEvent::Change) { + this.save(cx); + } + }); + let focus = editor.focus_handle(cx); + window.defer(cx, move |window, cx| focus.focus(window, cx)); + Self { + editor, + preview_view, + previewing: false, + preview_seq: 0, + answer_styles, + command, + mode: Mode::Normal, + anchor: 0, + visual_head: 0, + path, + notes_dir, + saved_text, + answers, + model: String::new(), + provider: Provider::Codex, + status: "i insert · v select · a ask · p read · : commands".into(), + pending: HashMap::new(), + request_seq: 0, + _subscription, + } + } + + fn save(&mut self, cx: &mut Context) { + let value = self.editor.read(cx).value().to_string(); + self.answers.reconcile(&self.saved_text, &value); + self.saved_text = value; + self.refresh_answer_styles(cx); + if let Err(error) = + fs::write(&self.path, &self.saved_text).and_then(|_| self.answers.save(&self.sidecar())) + { + self.status = format!("Could not save: {error}"); + } + cx.notify(); + } + + fn toggle_preview(&mut self, window: &mut Window, cx: &mut Context) { + self.previewing = !self.previewing; + if !self.previewing { + self.preview_seq += 1; + self.editor.update(cx, |state, cx| state.focus(window, cx)); + self.status = "i insert · v select · a ask · p read · : commands".into(); + } else { + self.preview_seq += 1; + let focus = self.preview_view.read(cx).focus_handle().clone(); + focus.focus(window, cx); + let seq = self.preview_seq; + let path = self.path.clone(); + let source = self.saved_text.clone(); + self.status = "Rendering document… · p source".into(); + let task = cx.background_spawn(async move { preview::render(&source, &path) }); + cx.spawn_in(window, async move |this, window| { + let (rendered, failures) = task.await; + _ = window.update(|_, cx| { + _ = this.update(cx, |this, cx| { + if !this.previewing || this.preview_seq != seq { return; } + this.preview_view.update(cx, |state, cx| state.set_text(&rendered, cx)); + this.status = if failures == 0 { + "Rendered document · p source · : commands".into() + } else { + format!("{failures} diagram(s) could not render; showing their source · p source") + }; + cx.notify(); + }); + }); + }).detach(); + } + cx.notify(); + } + + fn answer_decorations(answers: &Answers, text: &str) -> Vec { + answers + .items + .iter() + .filter_map(|answer| { + let start = answer.block_start.saturating_add(2); + let end = text + .get(start..answer.block_end)? + .find('\n') + .map(|n| start + n)?; + Some(TextDecoration::new( + start..end, + HighlightStyle { + color: Some(rgb(ACCENT).into()), + font_weight: Some(FontWeight::SEMIBOLD), + ..Default::default() + }, + )) + }) + .collect() + } + + fn refresh_answer_styles(&self, cx: &mut Context) { + self.answer_styles.set( + Self::answer_decorations(&self.answers, &self.saved_text), + cx, + ); + } + + fn open(&mut self, path: PathBuf, window: &mut Window, cx: &mut Context) { + self.save(cx); + let text = fs::read_to_string(&path).unwrap_or_default(); + self.answers = Answers::load(&path.with_extension("vool.json")); + self.saved_text = text.clone(); + self.path = path; + self.pending.clear(); + self.previewing = false; + self.preview_seq += 1; + self.mode = Mode::Normal; + self.status = "i insert · v select · a ask · p read · : commands".into(); + self.editor.update(cx, |state, cx| { + state.set_value(text, window, cx); + state.set_readonly(true, cx); + state.focus(window, cx); + }); + self.refresh_answer_styles(cx); + cx.notify(); + } + + fn new_note( + &mut self, + name: &str, + window: &mut Window, + cx: &mut Context, + ) -> Result<(), String> { + let path = if name.is_empty() { + let mut n = 1; + loop { + let path = self.notes_dir.join(format!("Untitled {n}.md")); + if !path.exists() { + break path; + } + n += 1; + } + } else { + if !valid_name(name) { + return Err("Use a file name without slashes or dots at the start".into()); + } + self.notes_dir + .join(format!("{}.md", name.trim_end_matches(".md"))) + }; + if path.exists() { + return Err("That note already exists. Use :open instead.".into()); + } + fs::write(&path, "").map_err(|error| format!("Could not create note: {error}"))?; + self.open(path, window, cx); + self.mode = Mode::Insert; + self.editor + .update(cx, |state, cx| state.set_readonly(false, cx)); + self.status = "Esc normal".into(); + cx.notify(); + Ok(()) + } + + fn run_command(&mut self, window: &mut Window, cx: &mut Context) { + let input = self.command.read(cx).value().to_string(); + let (verb, argument) = input.trim().split_once(' ').unwrap_or((input.trim(), "")); + let argument = argument.trim(); + let outcome = match verb { + "new" | "n" => self.new_note(argument, window, cx).err(), + "open" | "e" if valid_name(argument) => { + let path = self + .notes_dir + .join(format!("{}.md", argument.trim_end_matches(".md"))); + if path.exists() { + self.open(path, window, cx); + None + } else { + Some(format!( + "No note named {argument}. Use :files to list notes." + )) + } + } + "files" | "ls" => Some( + Self::files(&self.notes_dir) + .iter() + .map(|p| { + p.file_stem() + .unwrap_or_default() + .to_string_lossy() + .to_string() + }) + .collect::>() + .join(" · "), + ), + "w" => { + self.save(cx); + Some("Saved".into()) + } + "provider" if argument.is_empty() => Some("Providers: codex, openrouter".into()), + "provider" if argument == "codex" || argument == "openrouter" => { + self.provider = if argument == "codex" { + Provider::Codex + } else { + Provider::OpenRouter + }; + self.model.clear(); + Some(format!("Provider: {argument} · :model to select a model")) + } + "provider" => Some("Choose :provider codex or :provider openrouter".into()), + "model" if argument.is_empty() => Some(if self.provider == Provider::OpenRouter { + format!( + "OpenRouter default: {} · :model ID to override", + provider::OPENROUTER_MODEL + ) + } else { + "Codex default: CLI model · :model ID to override".into() + }), + "model" => { + self.model = if argument == "default" { + String::new() + } else { + argument.into() + }; + Some(format!("Model: {argument}")) + } + "preview" | "read" if !self.previewing => { + self.toggle_preview(window, cx); + None + } + "edit" if self.previewing => { + self.toggle_preview(window, cx); + None + } + _ => Some(format!( + "Unknown command: {verb}. Try :new, :open, :files, :w, :provider, :model, :preview, :edit" + )), + }; + if self.mode == Mode::Command { + self.set_mode(Mode::Normal, cx); + } + if let Some(message) = outcome { + self.status = message; + } + if self.previewing { + let focus = self.preview_view.read(cx).focus_handle().clone(); + focus.focus(window, cx); + } else { + self.editor.update(cx, |state, cx| state.focus(window, cx)); + } + cx.notify(); + } + + fn set_mode(&mut self, mode: Mode, cx: &mut Context) { + self.mode = mode; + self.editor + .update(cx, |state, cx| state.set_readonly(mode != Mode::Insert, cx)); + self.status = match mode { + Mode::Normal => { + if self.previewing { + "Rendered document · p source · : commands" + } else { + "i insert · v select · a ask · p read · : commands" + } + } + Mode::Insert => "Esc normal", + Mode::Visual => "h/j/k/l select · a ask · Esc cancel", + Mode::Command => "Enter run · Esc cancel", + } + .into(); + cx.notify(); + } + + fn move_cursor(&mut self, key: &str, cx: &mut Context) { + let text = self.editor.read(cx).value().to_string(); + let range = self.editor.read(cx).selected_range(); + let cursor = if self.mode == Mode::Visual { + self.visual_head + } else { + range.start + } + .min(text.len()); + let cursor = text.floor_char_boundary(cursor); + let next = match key { + "h" => text[..cursor].char_indices().last().map_or(0, |(i, _)| i), + "l" => cursor + text[cursor..].chars().next().map_or(0, char::len_utf8), + "0" => text[..cursor].rfind('\n').map_or(0, |i| i + 1), + "$" => text[cursor..].find('\n').map_or(text.len(), |i| cursor + i), + "j" | "k" => { + let start = text[..cursor].rfind('\n').map_or(0, |i| i + 1); + let col = cursor - start; + let line = if key == "j" { + let Some(i) = text[cursor..].find('\n') else { + return; + }; + cursor + i + 1 + } else { + if start == 0 { + return; + } + text[..start - 1].rfind('\n').map_or(0, |i| i + 1) + }; + let end = text[line..].find('\n').map_or(text.len(), |i| line + i); + (line + col.min(end - line)).min(text.len()) + } + _ => return, + }; + let next = text.floor_char_boundary(next); + let range = if self.mode == Mode::Visual { + self.visual_head = next; + self.anchor.min(next)..self.anchor.max(next) + } else { + next..next + }; + self.editor + .update(cx, |state, cx| state.set_selected_range(range, cx)); + cx.notify(); + } + + fn on_key(&mut self, event: &KeyDownEvent, window: &mut Window, cx: &mut Context) { + let key = event.keystroke.key.as_str(); + if key == "escape" { + cx.stop_propagation(); + self.set_mode(Mode::Normal, cx); + self.editor.update(cx, |state, cx| state.focus(window, cx)); + return; + } + if self.mode == Mode::Command { + if key == "enter" { + cx.stop_propagation(); + self.run_command(window, cx); + } + return; + } + if self.mode == Mode::Insert { + return; + } + if self.previewing { + if key == "p" { + cx.stop_propagation(); + self.toggle_preview(window, cx); + } else if key == ":" { + cx.stop_propagation(); + self.set_mode(Mode::Command, cx); + self.command.update(cx, |state, cx| { + state.set_value("", window, cx); + state.focus(window, cx); + }); + } + return; + } + match key { + "p" if self.mode == Mode::Normal => { + cx.stop_propagation(); + self.toggle_preview(window, cx); + } + ":" if self.mode == Mode::Normal => { + cx.stop_propagation(); + self.set_mode(Mode::Command, cx); + self.command.update(cx, |state, cx| { + state.set_value("", window, cx); + state.focus(window, cx); + }); + } + "i" if self.mode == Mode::Normal => { + cx.stop_propagation(); + self.set_mode(Mode::Insert, cx); + } + "v" if self.mode == Mode::Normal => { + cx.stop_propagation(); + self.anchor = self.editor.read(cx).selected_range().start; + self.visual_head = self.anchor; + self.set_mode(Mode::Visual, cx); + } + "a" if self.mode == Mode::Visual => { + cx.stop_propagation(); + self.ask(window, cx); + } + "h" | "j" | "k" | "l" | "0" | "$" => { + cx.stop_propagation(); + self.move_cursor(key, cx); + } + _ => {} + } + } + + fn write_answer(&mut self, id: u64, body: &str, window: &mut Window, cx: &mut Context) { + let mut text = self.editor.read(cx).value().to_string(); + self.answers.reconcile(&self.saved_text, &text); + self.answers.replace_block(id, &mut text, body); + self.saved_text = text.clone(); + let range = self + .answers + .items + .iter() + .find(|a| a.id == id) + .map(|a| a.start..a.end); + self.editor.update(cx, |state, cx| { + state.set_value(text, window, cx); + if let Some(range) = range { + state.set_selected_range(range, cx); + } + }); + self.save(cx); + } + + fn ask(&mut self, window: &mut Window, cx: &mut Context) { + let range = self.editor.read(cx).selected_range(); + let prompt = self.editor.read(cx).selected_value().to_string(); + if prompt.trim().is_empty() { + return; + } + let model = self.model.clone(); + let selected_model = if model.is_empty() && self.provider == Provider::OpenRouter { + provider::OPENROUTER_MODEL + } else if model.is_empty() { + "codex default" + } else { + &model + }; + let id = self.answers.ask(range, &prompt, selected_model); + self.request_seq += 1; + let request = self.request_seq; + self.pending.insert(id, request); + let path = self.path.clone(); + self.write_answer(id, "Thinking…", window, cx); + self.set_mode(Mode::Normal, cx); + self.status = if self.provider == Provider::Codex { + "Asking Codex…" + } else { + "Asking OpenRouter…" + } + .into(); + let model = self.model.clone(); + let provider = self.provider; + let task = cx.background_spawn(async move { + match provider { + Provider::Codex => codex_answer(&prompt, &model), + Provider::OpenRouter => provider::openrouter_answer( + &prompt, + if model.is_empty() { + provider::OPENROUTER_MODEL + } else { + &model + }, + ), + } + }); + cx.spawn_in(window, async move |this, window| { + let result = task.await; + _ = window.update(|window, cx| { + _ = this.update(cx, |this, cx| { + if this.path != path || this.pending.get(&id) != Some(&request) { + return; + } + this.pending.remove(&id); + let failed = result.is_err(); + let body = result.unwrap_or_else(|err| format!("Answer unavailable: {err}")); + this.write_answer(id, &body, window, cx); + this.status = if failed { + "Answer failed · check the inline message and retry".into() + } else { + "Answer ready · reselect question and press a to regenerate".into() + }; + cx.notify(); + }); + }); + }) + .detach(); + } +} + +fn codex_answer(prompt: &str, model: &str) -> Result { + let mut command = Command::new("codex"); + command.args(["exec", "--sandbox", "read-only", "--skip-git-repo-check"]); + if !model.is_empty() { + command.args(["--model", model]); + } + let mut child = command + .arg("-") + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .map_err(|e| format!("{e}. Install Codex CLI and run `codex login`"))?; + let instruction = format!( + "You are a thoughtful tutor in a learning notebook. Answer the selected question directly and clearly. Use Markdown. Do not edit files or run tools.\n\nSelected question:\n{prompt}" + ); + child + .stdin + .take() + .unwrap() + .write_all(instruction.as_bytes()) + .map_err(|e| e.to_string())?; + let output = child.wait_with_output().map_err(|e| e.to_string())?; + if output.status.success() { + Ok(String::from_utf8_lossy(&output.stdout).trim().to_string()) + } else { + Err(String::from_utf8_lossy(&output.stderr) + .chars() + .take(500) + .collect()) + } +} + +fn valid_name(name: &str) -> bool { + !name.is_empty() + && !name.starts_with('.') + && !name.contains(['/', '\\', '\0']) + && name != "." + && name != ".." +} + +#[cfg(test)] +mod command_tests { + use super::valid_name; + + #[test] + fn note_names_cannot_escape_notes_directory() { + assert!(valid_name("Thermodynamics")); + assert!(valid_name("Question 1.md")); + assert!(!valid_name("../secrets")); + assert!(!valid_name(".hidden")); + assert!(!valid_name("folder/note")); + } +} + +impl Render for Vool { + fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { + let title = self + .path + .file_stem() + .unwrap_or_default() + .to_string_lossy() + .to_string(); + let selected = self.editor.read(cx).selected_range().len() > 0; + let header = div() + .h(px(48.)) + .px_8() + .flex() + .items_center() + .justify_between() + .border_b_1() + .border_color(rgb(EDGE)) + .text_sm() + .child( + div() + .flex() + .items_center() + .gap_4() + .child(div().font_weight(FontWeight::SEMIBOLD).child("vool")) + .child(div().text_color(rgb(EDGE)).child("/")) + .child(div().text_color(rgb(MUTED)).child(format!("{title}.md"))), + ) + .child(div().text_xs().text_color(rgb(MUTED)).child(format!( + "{} / {}", + if self.provider == Provider::Codex { + "CODEX" + } else { + "OPENROUTER" + }, + if self.model.is_empty() { + if self.provider == Provider::Codex { + "DEFAULT" + } else { + provider::OPENROUTER_MODEL + } + } else { + &self.model + } + ))); + + let center = div() + .flex_1() + .min_w_0() + .h_full() + .flex() + .flex_col() + .bg(rgb(PAPER)) + .px(px(120.)) + .py(px(if self.previewing { 28. } else { 52. })) + .child( + div() + .flex_1() + .min_h_0() + .overflow_hidden() + .when(self.previewing, |this| { + this.child( + TextView::new(&self.preview_view) + .style(TextViewStyle { + heading_base_font_size: px(24.), + ..Default::default() + }) + .text_color(rgb(TEXT)) + .text_size(px(16.)) + .scrollable(true) + .size_full(), + ) + }) + .when(!self.previewing, |this| { + this.child( + Editor::new(&self.editor) + .appearance(false) + .bordered(false) + .readonly(self.mode != Mode::Insert) + .font_family("Noto Sans Mono") + .text_color(rgb(TEXT)) + .text_size(px(15.)) + .size_full(), + ) + }), + ); + let mode = match self.mode { + Mode::Normal => "NORMAL", + Mode::Insert => "INSERT", + Mode::Visual => "VISUAL", + Mode::Command => "COMMAND", + }; + let command_line = div() + .h(px(42.)) + .px_8() + .flex() + .items_center() + .gap_4() + .border_t_1() + .border_color(rgb(EDGE)) + .font_family("Noto Sans Mono") + .text_xs() + .child( + div() + .text_color(rgb(ACCENT)) + .font_weight(FontWeight::BOLD) + .child(mode), + ) + .when(self.mode == Mode::Command, |this| { + this.child(div().text_color(rgb(MUTED)).child(":")).child( + Input::new(&self.command) + .appearance(false) + .bordered(false) + .w(px(450.)) + .text_color(rgb(TEXT)), + ) + }) + .when(self.mode != Mode::Command, |this| { + this.child(div().text_color(rgb(MUTED)).child(self.status.clone())) + }) + .child(div().flex_1()) + .when( + selected && !self.previewing && self.mode != Mode::Command, + |this| { + this.child( + div() + .id("ask-selection") + .px_3() + .py_1() + .rounded_sm() + .bg(rgb(ACCENT)) + .text_color(rgb(PAPER)) + .cursor_pointer() + .child("Ask selection ↗") + .on_click(cx.listener(|this, _, window, cx| this.ask(window, cx))), + ) + }, + ); + + div() + .size_full() + .flex() + .flex_col() + .bg(rgb(BG)) + .text_color(rgb(TEXT)) + .font_family("Noto Sans") + .capture_key_down(cx.listener(Self::on_key)) + .child(header) + .child(center) + .child(command_line) + } +} + +fn main() { + gpui_kit::application().run(|cx| { + gpui_kit::init(cx); + let bounds = WindowBounds::centered(size(px(1320.), px(820.)), cx); + cx.spawn(async move |cx| { + cx.open_window( + WindowOptions { + window_bounds: Some(bounds), + ..Default::default() + }, + |window, cx| { + let view = cx.new(|cx| Vool::new(window, cx)); + cx.new(|cx| Root::new(view, window, cx)) + }, + ) + .expect("open Vool window"); + }) + .detach(); + }); +}

Build GPUI learning notebook with AI and rich reading mode

Changes