tenant.openagents/omega

1use chrono::{Datelike, Local, NaiveTime, Timelike};
2use editor::scroll::Autoscroll;
3use editor::{Editor, SelectionEffects};
4use gpui::{App, AppContext as _, Context, TaskExt, Window, actions};
5pub use settings::HourFormat;
6use settings::{RegisterSetting, Settings};
7use std::{
8    fs::OpenOptions,
9    path::{Path, PathBuf},
10    sync::Arc,
11};
12use workspace::{AppState, OpenResult, OpenVisible, Workspace};
13
14actions!(
15    journal,
16    [
17        /// Creates a new journal entry for today.
18        NewJournalEntry
19    ]
20);
21
22/// Settings specific to journaling
23#[derive(Clone, Debug, RegisterSetting)]
24pub struct JournalSettings {
25    /// The path of the directory where journal entries are stored.
26    ///
27    /// Default: `~`
28    pub path: String,
29    /// What format to display the hours in.
30    ///
31    /// Default: hour12
32    pub hour_format: HourFormat,
33}
34
35impl settings::Settings for JournalSettings {
36    fn from_settings(content: &settings::SettingsContent) -> Self {
37        let journal = content.journal.clone().unwrap();
38
39        Self {
40            path: journal.path.unwrap(),
41            hour_format: journal.hour_format.unwrap(),
42        }
43    }
44}
45
46pub fn init(_: Arc<AppState>, cx: &mut App) {
47    cx.observe_new(
48        |workspace: &mut Workspace, _window, _cx: &mut Context<Workspace>| {
49            workspace.register_action(|workspace, _: &NewJournalEntry, window, cx| {
50                new_journal_entry(workspace, window, cx);
51            });
52        },
53    )
54    .detach();
55}
56
57pub fn new_journal_entry(workspace: &Workspace, window: &mut Window, cx: &mut App) {
58    let settings = JournalSettings::get_global(cx);
59    let journal_dir = match journal_dir(&settings.path) {
60        Some(journal_dir) => journal_dir,
61        None => {
62            log::error!("Can't determine journal directory");
63            return;
64        }
65    };
66    let journal_dir_clone = journal_dir.clone();
67
68    let now = Local::now();
69    let month_dir = journal_dir
70        .join(format!("{:02}", now.year()))
71        .join(format!("{:02}", now.month()));
72    let entry_path = month_dir.join(format!("{:02}.md", now.day()));
73    let now = now.time();
74    let entry_heading = heading_entry(now, &settings.hour_format);
75
76    let create_entry = cx.background_spawn(async move {
77        std::fs::create_dir_all(month_dir)?;
78        OpenOptions::new()
79            .create(true)
80            .truncate(false)
81            .write(true)
82            .open(&entry_path)?;
83        Ok::<_, std::io::Error>((journal_dir, entry_path))
84    });
85
86    let worktrees = workspace.visible_worktrees(cx).collect::<Vec<_>>();
87    let mut open_new_workspace = true;
88    'outer: for worktree in worktrees.iter() {
89        let worktree_root = worktree.read(cx).abs_path();
90        if *worktree_root == journal_dir_clone {
91            open_new_workspace = false;
92            break;
93        }
94        for directory in worktree.read(cx).directories(true, 1) {
95            let full_directory_path = worktree_root.join(directory.path.as_std_path());
96            if full_directory_path.ends_with(&journal_dir_clone) {
97                open_new_workspace = false;
98                break 'outer;
99            }
100        }
101    }
102
103    let app_state = workspace.app_state().clone();
104    let view_snapshot = workspace.weak_handle();
105
106    window
107        .spawn(cx, async move |cx| {
108            let (journal_dir, entry_path) = create_entry.await?;
109            let opened = if open_new_workspace {
110                let OpenResult {
111                    window: new_workspace,
112                    ..
113                } = cx
114                    .update(|_window, cx| {
115                        workspace::open_paths(
116                            &[journal_dir],
117                            app_state,
118                            workspace::OpenOptions::default(),
119                            cx,
120                        )
121                    })?
122                    .await?;
123                new_workspace
124                    .update(cx, |multi_workspace, window, cx| {
125                        let workspace = multi_workspace.workspace().clone();
126                        workspace.update(cx, |workspace, cx| {
127                            workspace.open_paths(
128                                vec![entry_path],
129                                workspace::OpenOptions {
130                                    visible: Some(OpenVisible::All),
131                                    ..Default::default()
132                                },
133                                None,
134                                window,
135                                cx,
136                            )
137                        })
138                    })?
139                    .await
140            } else {
141                view_snapshot
142                    .update_in(cx, |workspace, window, cx| {
143                        workspace.open_paths(
144                            vec![entry_path],
145                            workspace::OpenOptions {
146                                visible: Some(OpenVisible::All),
147                                ..Default::default()
148                            },
149                            None,
150                            window,
151                            cx,
152                        )
153                    })?
154                    .await
155            };
156
157            if let Some(Some(Ok(item))) = opened.first()
158                && let Some(editor) = item.downcast::<Editor>().map(|editor| editor.downgrade())
159            {
160                editor.update_in(cx, |editor, window, cx| {
161                    let len = editor.buffer().read(cx).len(cx);
162                    editor.change_selections(
163                        SelectionEffects::scroll(Autoscroll::center()),
164                        window,
165                        cx,
166                        |s| s.select_ranges([len..len]),
167                    );
168                    if len.0 > 0 {
169                        editor.insert("\n\n", window, cx);
170                    }
171                    editor.insert(&entry_heading, window, cx);
172                    editor.insert("\n\n", window, cx);
173                })?;
174            }
175
176            anyhow::Ok(())
177        })
178        .detach_and_log_err(cx);
179}
180
181fn journal_dir(path: &str) -> Option<PathBuf> {
182    let expanded = shellexpand::full(path).ok()?;
183    let base_path = Path::new(expanded.as_ref());
184    let absolute_path = if base_path.is_absolute() {
185        base_path.to_path_buf()
186    } else {
187        log::warn!("Invalid journal path {path:?} (not absolute), falling back to home directory",);
188        std::env::home_dir()?
189    };
190    Some(absolute_path.join("journal"))
191}
192
193fn heading_entry(now: NaiveTime, hour_format: &HourFormat) -> String {
194    match hour_format {
195        HourFormat::Hour24 => {
196            let hour = now.hour();
197            format!("# {}:{:02}", hour, now.minute())
198        }
199        HourFormat::Hour12 => {
200            let (pm, hour) = now.hour12();
201            let am_or_pm = if pm { "PM" } else { "AM" };
202            format!("# {}:{:02} {}", hour, now.minute(), am_or_pm)
203        }
204    }
205}
206
207#[cfg(test)]
208mod tests {
209    mod heading_entry_tests {
210        use super::super::*;
211
212        #[test]
213        fn test_heading_entry_defaults_to_hour_12() {
214            let naive_time = NaiveTime::from_hms_milli_opt(15, 0, 0, 0).unwrap();
215            let actual_heading_entry = heading_entry(naive_time, &HourFormat::Hour12);
216            let expected_heading_entry = "# 3:00 PM";
217
218            assert_eq!(actual_heading_entry, expected_heading_entry);
219        }
220
221        #[test]
222        fn test_heading_entry_is_hour_12() {
223            let naive_time = NaiveTime::from_hms_milli_opt(15, 0, 0, 0).unwrap();
224            let actual_heading_entry = heading_entry(naive_time, &HourFormat::Hour12);
225            let expected_heading_entry = "# 3:00 PM";
226
227            assert_eq!(actual_heading_entry, expected_heading_entry);
228        }
229
230        #[test]
231        fn test_heading_entry_is_hour_24() {
232            let naive_time = NaiveTime::from_hms_milli_opt(15, 0, 0, 0).unwrap();
233            let actual_heading_entry = heading_entry(naive_time, &HourFormat::Hour24);
234            let expected_heading_entry = "# 15:00";
235
236            assert_eq!(actual_heading_entry, expected_heading_entry);
237        }
238    }
239
240    mod journal_dir_tests {
241        use super::super::*;
242
243        #[test]
244        #[cfg(target_family = "unix")]
245        fn test_absolute_unix_path() {
246            let result = journal_dir("/home/user");
247            assert!(result.is_some());
248            let path = result.unwrap();
249            assert!(path.is_absolute());
250            assert_eq!(path, PathBuf::from("/home/user/journal"));
251        }
252
253        #[test]
254        fn test_tilde_expansion() {
255            let result = journal_dir("~/documents");
256            assert!(result.is_some());
257            let path = result.unwrap();
258
259            assert!(path.is_absolute(), "Tilde should expand to absolute path");
260
261            if let Some(home) = std::env::home_dir() {
262                assert_eq!(path, home.join("documents").join("journal"));
263            }
264        }
265
266        #[test]
267        fn test_relative_path_falls_back_to_home() {
268            for relative_path in ["relative/path", "NONEXT/some/path", "../some/path"] {
269                let result = journal_dir(relative_path);
270                assert!(result.is_some(), "Failed for path: {}", relative_path);
271                let path = result.unwrap();
272
273                assert!(
274                    path.is_absolute(),
275                    "Path should be absolute for input '{}', got: {:?}",
276                    relative_path,
277                    path
278                );
279
280                if let Some(home) = std::env::home_dir() {
281                    assert_eq!(
282                        path,
283                        home.join("journal"),
284                        "Should fall back to home directory for input '{}'",
285                        relative_path
286                    );
287                }
288            }
289        }
290
291        #[test]
292        #[cfg(target_os = "windows")]
293        fn test_absolute_path_windows_style() {
294            let result = journal_dir("C:\\Users\\user\\Documents");
295            assert!(result.is_some());
296            let path = result.unwrap();
297            assert_eq!(path, PathBuf::from("C:\\Users\\user\\Documents\\journal"));
298        }
299    }
300}
301