Track task progress and organize Galaxy Drive plans

2026-10-20 21:57:15 +00:00
parent cb830e1ba7
commit 7ccb0e9abc
30 changed files with 2791 additions and 105 deletions
@@ -0,0 +1,417 @@
+use std::sync::mpsc::sync_channel;
+
+use ai::document::AIDocumentId;
+use galaxyui::App;
+
+use super::*;
+use crate::notebooks::CloudNotebookModel;
+use crate::persistence::ModelEvent;
+use crate::test_util::settings::initialize_settings_for_tests;
+
+fn completed_plan(completed_at: DateTime<Utc>) -> CompletedPlan {
+    CompletedPlan {
+        conversation_id: AIConversationId::new(),
+        completed_at,
+        archived_to: None,
+        original_folder: None,
+    }
+}
+
+#[test]
+fn completed_plan_archives_after_seven_full_days_only() {
+    let now = Utc::now();
+    let plan = completed_plan(now - chrono::Duration::days(7));
+    assert!(!plan.is_due(now - chrono::Duration::milliseconds(1)));
+    assert!(plan.is_due(now));
+    assert!(!completed_plan(now + chrono::Duration::days(1)).is_due(now));
+}
+
+#[test]
+fn archived_plan_deadline_and_recovery_location_survive_restart() {
+    let mut plan = completed_plan(Utc::now() - chrono::Duration::days(8));
+    plan.archived_to = Some(SyncId::ClientId(ClientId::new()));
+    plan.original_folder = Some(SyncId::ClientId(ClientId::new()));
+    let serialized = serde_json::to_string(&plan).unwrap();
+    let restored: CompletedPlan = serde_json::from_str(&serialized).unwrap();
+    assert_eq!(restored, plan);
+    assert!(!restored.is_due(Utc::now()));
+}
+
+#[test]
+fn revisiting_a_completed_plan_preserves_its_original_deadline() {
+    let mut model = PlanArchivalModel {
+        completed_plans: HashMap::new(),
+        ..Default::default()
+    };
+    let conversation_id = AIConversationId::new();
+    let completed_at = Utc::now() - chrono::Duration::days(6);
+    model.observe_completion("plan".to_string(), conversation_id, completed_at);
+    model.observe_completion("plan".to_string(), conversation_id, Utc::now());
+    assert_eq!(model.completed_plans["plan"].completed_at, completed_at);
+}
+
+#[test]
+fn legacy_completed_plan_records_are_preserved() {
+    let record = completed_plan(Utc::now() - chrono::Duration::days(4));
+    let records = HashMap::from([("plan".to_string(), record.clone())]);
+    let json = serde_json::to_string(&records).unwrap();
+    let model = PlanArchivalModel::from_persisted(&json).unwrap();
+    assert_eq!(model.completed_plans["plan"], record);
+    assert!(model.reopened_plans.is_empty());
+}
+
+#[test]
+fn dirty_and_reverted_plans_stay_visible_until_new_work_accepts_the_edits() {
+    App::test((), |mut app| async move {
+        initialize_settings_for_tests(&mut app);
+        app.add_singleton_model(|_| CloudModel::new(None, Vec::new(), None));
+        app.add_singleton_model(|_| BlocklistAIHistoryModel::new_for_test());
+        let documents = app.add_singleton_model(|_| AIDocumentModel::new_for_test());
+        let repository = app.add_singleton_model(|ctx| {
+            LocalObjectRepository::new(None, None, ctx)
+        });
+        let document_id = AIDocumentId::new();
+        let notebook_id = SyncId::ClientId(ClientId::new());
+        repository.update(&mut app, |repository, ctx| {
+            repository.create_notebook_with_id(
+                notebook_id,
+                None,
+                CloudNotebookModel {
+                    title: "Reopened plan".to_string(),
+                    data: "New unfinished work".to_string(),
+                    ai_document_id: Some(document_id),
+                    conversation_id: None,
+                },
+                ctx,
+            );
+        });
+        let archival = app.add_model(PlanArchivalModel::new);
+        let conversation_id = AIConversationId::new();
+        let old_completion = Utc::now() - chrono::Duration::days(8);
+        archival.update(&mut app, |model, ctx| {
+            model.observe_completion(document_id.to_string(), conversation_id, old_completion);
+            model.archive_plan(&document_id.to_string(), ctx);
+        });
+        assert!(CloudModel::as_ref(&app)
+            .get_notebook(&notebook_id)
+            .unwrap()
+            .metadata
+            .folder_id
+            .is_some());
+
+        // Typing in the editor emits Dirty; reverting a version also emits a
+        // user-originated DocumentUpdated event. Either must reopen the plan.
+        for event in [
+            AIDocumentModelEvent::DocumentUserEditStatusUpdated {
+                document_id,
+                status: AIDocumentUserEditStatus::Dirty,
+            },
+            AIDocumentModelEvent::DocumentUpdated {
+                document_id,
+                version: Default::default(),
+                source: AIDocumentUpdateSource::User,
+            },
+        ] {
+            documents.update(&mut app, |_, ctx| ctx.emit(event));
+            archival.update(&mut app, |model, ctx| {
+                model.observe_completion(document_id.to_string(), conversation_id, old_completion);
+                model.sweep(ctx);
+                assert!(!model.completed_plans.contains_key(&document_id.to_string()));
+                assert_eq!(
+                    model.reopened_plans[&document_id.to_string()].conversation_id,
+                    conversation_id,
+                );
+                let json = serde_json::to_string(model).unwrap();
+                let mut restored = PlanArchivalModel::from_persisted(&json).unwrap();
+                restored.observe_completion(
+                    document_id.to_string(),
+                    conversation_id,
+                    old_completion,
+                );
+                assert!(restored.completed_plans.is_empty());
+            });
+            assert!(CloudModel::as_ref(&app)
+                .get_notebook(&notebook_id)
+                .unwrap()
+                .metadata
+                .folder_id
+                .is_none());
+        }
+
+        archival.update(&mut app, |model, ctx| {
+            // Merely restoring clean editor state cannot close a reopened plan.
+            model.accept_document_edits(document_id, ctx);
+            assert!(model.reopened_plans.contains_key(&document_id.to_string()));
+            model.begin_exchange(conversation_id, ctx);
+            assert!(model.reopened_plans.contains_key(&document_id.to_string()));
+            model.accept_document_edits(document_id, ctx);
+            assert!(model.reopened_plans.is_empty());
+            let finished_again = Utc::now();
+            model.observe_completion(document_id.to_string(), conversation_id, finished_again);
+            assert_eq!(model.completed_plans[&document_id.to_string()].completed_at, finished_again);
+            assert!(!model.completed_plans[&document_id.to_string()].is_due(finished_again));
+        });
+    });
+}
+
+#[test]
+fn a_successful_draft_conversation_does_not_complete_a_plan() {
+    let mut conversation = AIConversation::new(false, false);
+    conversation.set_status_for_test(ConversationStatus::Success);
+    assert!(completed_work_time(&conversation).is_none());
+
+    for status in [
+        ConversationStatus::InProgress,
+        ConversationStatus::WaitingForEvents,
+        ConversationStatus::TransientError,
+        ConversationStatus::Error,
+        ConversationStatus::Cancelled,
+    ] {
+        conversation.set_status_for_test(status);
+        assert!(completed_work_time(&conversation).is_none());
+    }
+}
+
+#[test]
+fn archival_preserves_notebook_and_resuming_restores_original_folder() {
+    App::test((), |mut app| async move {
+        initialize_settings_for_tests(&mut app);
+        let (sender, receiver) = sync_channel(32);
+        app.add_singleton_model(|_| CloudModel::new(None, Vec::new(), None));
+        app.add_singleton_model(|_| BlocklistAIHistoryModel::new_for_test());
+        app.add_singleton_model(|_| AIDocumentModel::new_for_test());
+        let repository = app.add_singleton_model(|ctx| {
+            LocalObjectRepository::new(Some(sender), None, ctx)
+        });
+        let archival = app.add_model(|_| PlanArchivalModel {
+            completed_plans: HashMap::new(),
+            ..Default::default()
+        });
+        let original_folder = SyncId::ClientId(ClientId::new());
+        let notebook_id = SyncId::ClientId(ClientId::new());
+        let document_id = AIDocumentId::new();
+        let notebook_model = CloudNotebookModel {
+            title: "Retained plan".to_string(),
+            data: "# Plan\n- [x] Finished work".to_string(),
+            ai_document_id: Some(document_id),
+            conversation_id: None,
+        };
+        repository.update(&mut app, |repository, ctx| {
+            repository.create_folder_with_id(
+                original_folder,
+                "Project".to_string(),
+                None,
+                ctx,
+            );
+            repository.create_notebook_with_id(
+                notebook_id,
+                Some(original_folder),
+                notebook_model.clone(),
+                ctx,
+            );
+        });
+        let conversation_id = AIConversationId::new();
+        archival.update(&mut app, |model, ctx| {
+            model.observe_completion(
+                document_id.to_string(),
+                conversation_id,
+                Utc::now() - chrono::Duration::days(8),
+            );
+            model.persist(ctx);
+        });
+
+        // Simulate startup with persisted completion records and no loaded
+        // conversations/documents. The notebook is still retained in Drive.
+        let archival = app.add_model(PlanArchivalModel::new);
+        archival.update(&mut app, |model, ctx| model.sweep(ctx));
+
+        let archive_folder = archival.read(&app, |model, _| {
+            model.completed_plans[&document_id.to_string()]
+                .archived_to
+                .expect("plan should have been archived")
+        });
+        let cloud_model = CloudModel::as_ref(&app);
+        let notebook = cloud_model.get_notebook(&notebook_id).unwrap();
+        assert_eq!(notebook.model(), &notebook_model);
+        assert_eq!(notebook.metadata.folder_id, Some(archive_folder));
+        assert!(!notebook.is_trashed(cloud_model));
+        let folder = cloud_model.get_folder(&archive_folder).unwrap();
+        assert_eq!(folder.model().name, ARCHIVE_FOLDER_NAME);
+        let parent = cloud_model
+            .get_folder(&folder.metadata.folder_id.unwrap())
+            .unwrap();
+        assert_eq!(parent.model().name, PLAN_FOLDER_NAME);
+
+        let events = receiver.try_iter().collect::<Vec<_>>();
+        assert!(events.iter().any(|event| matches!(
+            event,
+            ModelEvent::UpsertNotebook { notebook }
+                if notebook.id == notebook_id
+                    && notebook.metadata.folder_id == Some(archive_folder)
+                    && notebook.model() == &notebook_model
+        )));
+        assert!(!events.iter().any(|event| matches!(event, ModelEvent::DeleteObjects { .. })));
+
+        archival.update(&mut app, |model, ctx| {
+            model.resume_conversation(conversation_id, ctx);
+            assert!(model.completed_plans.is_empty());
+        });
+        let cloud_model = CloudModel::as_ref(&app);
+        let notebook = cloud_model.get_notebook(&notebook_id).unwrap();
+        assert_eq!(notebook.metadata.folder_id, Some(original_folder));
+        assert_eq!(notebook.model(), &notebook_model);
+        assert!(!notebook.is_trashed(cloud_model));
+    });
+}
+
+#[test]
+fn manual_restore_does_not_rearchive_a_completed_plan() {
+    App::test((), |mut app| async move {
+        initialize_settings_for_tests(&mut app);
+        app.add_singleton_model(|_| CloudModel::new(None, Vec::new(), None));
+        app.add_singleton_model(|_| BlocklistAIHistoryModel::new_for_test());
+        app.add_singleton_model(|_| AIDocumentModel::new_for_test());
+        let repository = app.add_singleton_model(|ctx| {
+            LocalObjectRepository::new(None, None, ctx)
+        });
+        let archive_folder = SyncId::ClientId(ClientId::new());
+        let notebook_id = SyncId::ClientId(ClientId::new());
+        let document_id = AIDocumentId::new();
+        repository.update(&mut app, |repository, ctx| {
+            repository.create_folder_with_id(archive_folder, "Archive".to_string(), None, ctx);
+            repository.create_notebook_with_id(
+                notebook_id,
+                Some(archive_folder),
+                CloudNotebookModel {
+                    title: "Recovered plan".to_string(),
+                    data: "Keep this plan visible".to_string(),
+                    ai_document_id: Some(document_id),
+                    conversation_id: None,
+                },
+                ctx,
+            );
+        });
+        let mut record = completed_plan(Utc::now() - chrono::Duration::days(8));
+        record.archived_to = Some(archive_folder);
+        let archival = app.add_model(|_| PlanArchivalModel {
+            completed_plans: HashMap::from([(document_id.to_string(), record)]),
+            ..Default::default()
+        });
+
+        assert!(repository.update(&mut app, |repository, ctx| {
+            repository.move_object_to_location(
+                CloudObjectTypeAndId::Notebook(notebook_id),
+                CloudObjectLocation::Space(Space::Personal),
+                ctx,
+            )
+        }));
+        archival.update(&mut app, |model, ctx| model.sweep(ctx));
+
+        let cloud_model = CloudModel::as_ref(&app);
+        let notebook = cloud_model.get_notebook(&notebook_id).unwrap();
+        assert!(notebook.metadata.folder_id.is_none());
+        assert_eq!(notebook.model().data, "Keep this plan visible");
+        archival.read(&app, |model, _| {
+            assert!(!model.completed_plans[&document_id.to_string()].is_due(Utc::now()));
+        });
+    });
+}
+
+#[test]
+fn ordinary_notebooks_are_never_archived() {
+    App::test((), |mut app| async move {
+        initialize_settings_for_tests(&mut app);
+        app.add_singleton_model(|_| CloudModel::new(None, Vec::new(), None));
+        app.add_singleton_model(|_| AIDocumentModel::new_for_test());
+        let repository = app.add_singleton_model(|ctx| {
+            LocalObjectRepository::new(None, None, ctx)
+        });
+        let notebook_id = SyncId::ClientId(ClientId::new());
+        repository.update(&mut app, |repository, ctx| {
+            repository.create_notebook_with_id(
+                notebook_id,
+                None,
+                CloudNotebookModel {
+                    title: "Ordinary notes".to_string(),
+                    data: "Keep these notes".to_string(),
+                    ai_document_id: None,
+                    conversation_id: None,
+                },
+                ctx,
+            );
+        });
+        let archival = app.add_model(|_| PlanArchivalModel {
+            completed_plans: HashMap::new(),
+            ..Default::default()
+        });
+        archival.update(&mut app, |model, ctx| {
+            model.observe_completion(
+                notebook_id.to_string(),
+                AIConversationId::new(),
+                Utc::now() - chrono::Duration::days(8),
+            );
+            model.archive_plan(&notebook_id.to_string(), ctx);
+        });
+        let cloud_model = CloudModel::as_ref(&app);
+        let notebook = cloud_model.get_notebook(&notebook_id).unwrap();
+        assert!(notebook.metadata.folder_id.is_none());
+        assert_eq!(notebook.model().data, "Keep these notes");
+        assert_eq!(cloud_model.get_all_active_folders().count(), 0);
+    });
+}
+
+#[test]
+fn editing_an_archived_plan_from_drive_reopens_it_without_loading_its_conversation() {
+    App::test((), |mut app| async move {
+        initialize_settings_for_tests(&mut app);
+        app.add_singleton_model(|_| CloudModel::new(None, Vec::new(), None));
+        app.add_singleton_model(|_| BlocklistAIHistoryModel::new_for_test());
+        app.add_singleton_model(|_| AIDocumentModel::new_for_test());
+        let repository = app.add_singleton_model(|ctx| {
+            LocalObjectRepository::new(None, None, ctx)
+        });
+        let document_id = AIDocumentId::new();
+        let notebook_id = SyncId::ClientId(ClientId::new());
+        repository.update(&mut app, |repository, ctx| {
+            repository.create_notebook_with_id(
+                notebook_id,
+                None,
+                CloudNotebookModel {
+                    title: "Completed plan".to_string(),
+                    data: "- [x] Done".to_string(),
+                    ai_document_id: Some(document_id),
+                    conversation_id: None,
+                },
+                ctx,
+            );
+        });
+        let archival = app.add_model(PlanArchivalModel::new);
+        let conversation_id = AIConversationId::new();
+        let completed_at = Utc::now() - chrono::Duration::days(8);
+        archival.update(&mut app, |model, ctx| {
+            model.observe_completion(document_id.to_string(), conversation_id, completed_at);
+            model.archive_plan(&document_id.to_string(), ctx);
+        });
+        repository.update(&mut app, |repository, ctx| {
+            repository.update_notebook_data(
+                notebook_id,
+                "- [ ] New unfinished work".to_string(),
+                ctx,
+            );
+        });
+        archival.update(&mut app, |model, ctx| {
+            model.observe_completion(document_id.to_string(), conversation_id, completed_at);
+            model.sweep(ctx);
+            assert!(model.completed_plans.is_empty());
+            assert_eq!(
+                model.reopened_plans[&document_id.to_string()].conversation_id,
+                conversation_id,
+            );
+        });
+        let cloud_model = CloudModel::as_ref(&app);
+        let notebook = cloud_model.get_notebook(&notebook_id).unwrap();
+        assert!(notebook.metadata.folder_id.is_none());
+        assert_eq!(notebook.model().data, "- [ ] New unfinished work");
+        assert!(!notebook.is_trashed(cloud_model));
+    });
+}