`b2c7109`

Add local event copy flow

Authored by

espadonne 2 weeks ago

SHA: b2c7109935d5381f346ae77c5f6b2e960f57c980
Parents: 04203a9
Tree: 37e0ce7

5 changed files

Status	File	+	-
M	`README.md`	1	0
M	`src/agenda.rs`	200	0
M	`src/app.rs`	337	1
M	`src/cli.rs`	30	2
M	`src/tui.rs`	101	2

README.mdmodified

  - Arrow keys move the selected date.
  - `?` opens contextual help.
  - `+` opens the Create event modal.
 +- In day view, `c` opens the Copy confirmation for the selected local event.
  - In day view, `d` opens the Delete confirmation for the selected local event.
  - `Enter` opens the focused day view.
  - `Esc` returns from day view to month view.

src/agenda.rsmodified

+ }
  impl CreateEventDraft {
 +    pub fn from_event(event: &Event) -> Self {
 +        Self {
 +            title: event.title.clone(),
 +            timing: match event.timing {
 +                EventTiming::AllDay { date } => CreateEventTiming::AllDay { date },
 +                EventTiming::Timed { start, end } => CreateEventTiming::Timed { start, end },
 +            },
 +            location: event.location.clone(),
 +            notes: event.notes.clone(),
 +            reminders: event.reminders.clone(),
 +            recurrence: event.recurrence.clone(),
 +        }
 +    }
++
      pub fn into_event(self, id: String) -> Result<Event, AgendaError> {
          let source = SourceMetadata::local().with_external_id(id.clone());
          let mut event = match self.timing {
          Ok(deleted)
+     }
 +    pub fn duplicate_event(&mut self, id: &str) -> Result<Event, LocalEventStoreError> {
 +        let event = self
 +            .events
 +            .local_event_by_id(id)
 +            .ok_or_else(|| LocalEventStoreError::EventNotFound { id: id.to_string() })?;
 +        self.insert_event_copy(event)
 +    }
++
 +    pub fn duplicate_occurrence(
 +        &mut self,
 +        series_id: &str,
 +        anchor: OccurrenceAnchor,
 +    ) -> Result<Event, LocalEventStoreError> {
 +        let series = self.events.local_event_by_id(series_id).ok_or_else(|| {
 +            LocalEventStoreError::EventNotFound {
 +                id: series_id.to_string(),
 +            }
 +        })?;
 +        if !series.is_recurring_series() {
 +            return Err(LocalEventStoreError::EventNotEditable {
 +                id: series_id.to_string(),
 +            });
 +        }
 +        if !event_generates_anchor(&series, anchor) {
 +            return Err(LocalEventStoreError::OccurrenceNotFound {
 +                id: series_id.to_string(),
 +                anchor: anchor.storage_key(),
 +            });
 +        }
++
 +        let occurrence = occurrence_override_event(&series, anchor)
 +            .unwrap_or_else(|| generated_occurrence_event(&series, anchor));
 +        let draft = CreateEventDraft::from_event(&occurrence).without_recurrence();
 +        self.create_event(draft)
 +    }
++
      pub fn delete_occurrence(
          &mut self,
          series_id: &str,
          Ok(())
+     }
 +    fn insert_event_copy(&mut self, mut event: Event) -> Result<Event, LocalEventStoreError> {
 +        let id = self.next_local_event_id(&event.title);
 +        event.id = id.clone();
 +        event.source = SourceMetadata::local().with_external_id(id);
 +        event.occurrence = None;
++
 +        if let Some(path) = &self.events_file {
 +            let mut events = self.events.events().to_vec();
 +            events.push(event.clone());
 +            write_events_file(path, &events)?;
 +        }
 +        self.events.push_event(event.clone());
 +        Ok(event)
 +    }
++
      fn next_local_event_id(&self, title: &str) -> String {
          let now = SystemTime::now()
              .duration_since(UNIX_EPOCH)
          assert_eq!(agenda.all_day_events[0].location.as_deref(), Some("Room 2"));
+     }
 +    #[test]
 +    fn local_event_store_duplicates_single_event_and_persists() {
 +        let path = temp_events_path("duplicate-event");
 +        let _ = std::fs::remove_dir_all(path.parent().expect("path has parent"));
 +        let day = date(23);
 +        let mut source = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
 +            .expect("missing event file is empty");
 +        let event = source
 +            .create_event(CreateEventDraft {
 +                title: "Planning".to_string(),
 +                timing: CreateEventTiming::Timed {
 +                    start: at(day, 9, 0),
 +                    end: at(day, 10, 0),
 +                },
 +                location: Some("Room 1".to_string()),
 +                notes: Some("Bring notes".to_string()),
 +                reminders: vec![Reminder::minutes_before(15)],
 +                recurrence: None,
 +            })
 +            .expect("event saves");
++
 +        let copied = source.duplicate_event(&event.id).expect("event copies");
 +        let reloaded = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
 +            .expect("saved file reloads");
 +        let agenda = DayAgenda::from_source(day, &reloaded);
++
 +        let _ = std::fs::remove_dir_all(path.parent().expect("test dir exists"));
++
 +        assert_ne!(copied.id, event.id);
 +        assert!(copied.is_local());
 +        assert_eq!(copied.title, "Planning");
 +        assert_eq!(copied.location.as_deref(), Some("Room 1"));
 +        assert_eq!(agenda.timed_events.len(), 2);
 +    }
++
 +    #[test]
 +    fn local_event_store_duplicates_occurrence_as_standalone_event() {
 +        let path = temp_events_path("duplicate-occurrence");
 +        let _ = std::fs::remove_dir_all(path.parent().expect("path has parent"));
 +        let day = date(23);
 +        let mut source = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
 +            .expect("missing event file is empty");
 +        let event = source
 +            .create_event(CreateEventDraft {
 +                title: "Standup".to_string(),
 +                timing: CreateEventTiming::Timed {
 +                    start: at(day, 9, 0),
 +                    end: at(day, 9, 30),
 +                },
 +                location: None,
 +                notes: None,
 +                reminders: Vec::new(),
 +                recurrence: Some(RecurrenceRule {
 +                    frequency: RecurrenceFrequency::Daily,
 +                    interval: 1,
 +                    end: RecurrenceEnd::Count(2),
 +                    weekdays: Vec::new(),
 +                    monthly: None,
 +                    yearly: None,
 +                }),
 +            })
 +            .expect("recurring event saves");
 +        let anchor = OccurrenceAnchor::Timed {
 +            start: at(day.add_days(1), 9, 0),
 +        };
++
 +        let copied = source
 +            .duplicate_occurrence(&event.id, anchor)
 +            .expect("occurrence copies");
 +        let reloaded = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
 +            .expect("saved file reloads");
 +        let agenda = DayAgenda::from_source(day.add_days(1), &reloaded);
++
 +        let _ = std::fs::remove_dir_all(path.parent().expect("test dir exists"));
++
 +        assert_ne!(copied.id, event.id);
 +        assert!(copied.occurrence().is_none());
 +        assert!(copied.recurrence.is_none());
 +        assert_eq!(agenda.timed_events.len(), 2);
 +        assert!(
 +            agenda
 +                .timed_events
 +                .iter()
 +                .any(|agenda_event| agenda_event.event.id == copied.id)
 +        );
 +    }
++
 +    #[test]
 +    fn local_event_store_duplicates_recurring_series() {
 +        let path = temp_events_path("duplicate-series");
 +        let _ = std::fs::remove_dir_all(path.parent().expect("path has parent"));
 +        let day = date(23);
 +        let mut source = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
 +            .expect("missing event file is empty");
 +        let event = source
 +            .create_event(CreateEventDraft {
 +                title: "Standup".to_string(),
 +                timing: CreateEventTiming::Timed {
 +                    start: at(day, 9, 0),
 +                    end: at(day, 9, 30),
 +                },
 +                location: None,
 +                notes: None,
 +                reminders: Vec::new(),
 +                recurrence: Some(RecurrenceRule {
 +                    frequency: RecurrenceFrequency::Daily,
 +                    interval: 1,
 +                    end: RecurrenceEnd::Count(2),
 +                    weekdays: Vec::new(),
 +                    monthly: None,
 +                    yearly: None,
 +                }),
 +            })
 +            .expect("recurring event saves");
++
 +        let copied = source
 +            .duplicate_event(&event.id)
 +            .expect("recurring series copies");
 +        let reloaded = ConfiguredAgendaSource::from_events_file(&path, HolidayProvider::off())
 +            .expect("saved file reloads");
 +        let agenda = DayAgenda::from_source(day.add_days(1), &reloaded);
++
 +        let _ = std::fs::remove_dir_all(path.parent().expect("test dir exists"));
++
 +        assert_ne!(copied.id, event.id);
 +        assert!(copied.recurrence.is_some());
 +        assert_eq!(agenda.timed_events.len(), 2);
 +        assert!(
 +            agenda
 +                .timed_events
 +                .iter()
 +                .any(|agenda_event| agenda_event.event.id.starts_with(&copied.id))
 +        );
 +    }
++
      #[test]
      fn local_event_store_loads_version_one_and_rewrites_version_two_on_save() {
          let path = temp_events_path("version-one");

src/app.rsmodified

      create_form: Option<CreateEventForm>,
      recurrence_choice: Option<RecurrenceEditChoice>,
      delete_choice: Option<EventDeleteChoice>,
 +    copy_choice: Option<EventCopyChoice>,
      help_open: bool,
      selected_day_event_id: Option<String>,
      should_quit: bool,
              create_form: None,
              recurrence_choice: None,
              delete_choice: None,
 +            copy_choice: None,
              help_open: false,
              selected_day_event_id: None,
              should_quit: false,
          self.delete_choice.as_ref()
+     }
 +    pub const fn copy_choice(&self) -> Option<&EventCopyChoice> {
 +        self.copy_choice.as_ref()
 +    }
++
      pub fn selected_day_event_id(&self) -> Option<&str> {
          self.selected_day_event_id.as_deref()
+     }
          self.delete_choice.is_some()
+     }
 +    pub const fn is_copying_event(&self) -> bool {
 +        self.copy_choice.is_some()
 +    }
++
      pub const fn is_showing_help(&self) -> bool {
          self.help_open
+     }
          self.delete_choice = None;
+     }
 +    pub fn close_copy_choice(&mut self) {
 +        self.copy_choice = None;
 +    }
++
      pub fn close_help(&mut self) {
          self.help_open = false;
+     }
+         }
+     }
 +    pub fn set_copy_error(&mut self, message: impl Into<String>) {
 +        if let Some(choice) = &mut self.copy_choice {
 +            choice.error = Some(message.into());
 +        }
 +    }
++
      pub fn set_create_form_error(&mut self, message: impl Into<String>) {
          if let Some(form) = &mut self.create_form {
              form.error = Some(message.into());
+         }
+     }
 +    pub fn handle_copy_choice_key(&mut self, key: KeyEvent) -> EventCopyInputResult {
 +        if key.kind == KeyEventKind::Release {
 +            return EventCopyInputResult::Continue;
 +        }
++
 +        let Some(choice) = &mut self.copy_choice else {
 +            return EventCopyInputResult::Continue;
 +        };
++
 +        match key.code {
 +            KeyCode::Esc => EventCopyInputResult::Cancel,
 +            KeyCode::Up => {
 +                choice.select_previous();
 +                EventCopyInputResult::Continue
 +            }
 +            KeyCode::Down => {
 +                choice.select_next();
 +                EventCopyInputResult::Continue
 +            }
 +            KeyCode::Enter => match choice.selected_action() {
 +                EventCopyChoiceAction::Cancel => EventCopyInputResult::Cancel,
 +                EventCopyChoiceAction::CopyEvent => {
 +                    EventCopyInputResult::Submit(EventCopySubmission::Event {
 +                        event_id: choice.event_id().to_string(),
 +                    })
 +                }
 +                EventCopyChoiceAction::CopyThisOccurrence => {
 +                    let EventCopyTarget::Occurrence { series_id, anchor } = &choice.target else {
 +                        return EventCopyInputResult::Continue;
 +                    };
 +                    EventCopyInputResult::Submit(EventCopySubmission::Occurrence {
 +                        series_id: series_id.clone(),
 +                        anchor: *anchor,
 +                    })
 +                }
 +                EventCopyChoiceAction::CopySeries => {
 +                    let EventCopyTarget::Occurrence { series_id, .. } = &choice.target else {
 +                        return EventCopyInputResult::Continue;
 +                    };
 +                    EventCopyInputResult::Submit(EventCopySubmission::Series {
 +                        series_id: series_id.clone(),
 +                    })
 +                }
 +            },
 +            _ => EventCopyInputResult::Continue,
 +        }
 +    }
++
      pub fn handle_help_key(&mut self, key: KeyEvent) -> HelpInputResult {
          if key.kind == KeyEventKind::Release {
              return HelpInputResult::Continue;
              AppAction::OpenHelp
                  if self.create_form.is_none()
                      && self.recurrence_choice.is_none()
 -                    && self.delete_choice.is_none() =>
 +                    && self.delete_choice.is_none()
 +                    && self.copy_choice.is_none() =>
+             {
                  self.help_open = true;
+             }
                  self.selected_day_event_id = None;
                  self.recurrence_choice = None;
                  self.delete_choice = None;
 +                self.copy_choice = None;
                  self.help_open = false;
+             }
              AppAction::OpenCreate => {
                  if self.create_form.is_none()
                      && self.recurrence_choice.is_none()
                      && self.delete_choice.is_none()
 +                    && self.copy_choice.is_none()
                      && !self.help_open
+                 {
                      let context = match self.view_mode {
                  if self.create_form.is_none()
                      && self.recurrence_choice.is_none()
                      && self.delete_choice.is_none()
 +                    && self.copy_choice.is_none()
                      && !self.help_open
                      && let Some(source) = source
+                 {
                      self.open_selected_event_for_delete(source);
+                 }
+             }
 +            AppAction::OpenCopy if self.view_mode == ViewMode::Day => {
 +                if self.create_form.is_none()
 +                    && self.recurrence_choice.is_none()
 +                    && self.delete_choice.is_none()
 +                    && self.copy_choice.is_none()
 +                    && !self.help_open
 +                    && let Some(source) = source
 +                {
 +                    self.open_selected_event_for_copy(source);
 +                }
 +            }
              AppAction::MoveDays(days) if self.view_mode == ViewMode::Month => {
                  self.selected_date = self.selected_date.add_days(days);
+             }
              | AppAction::JumpToDay(_)
              | AppAction::JumpToWeekday(_)
              | AppAction::OpenDelete
 +            | AppAction::OpenCopy
              | AppAction::OpenHelp => {}
+         }
+     }
+         }
+     }
 +    fn open_selected_event_for_copy(&mut self, source: &dyn AgendaSource) {
 +        self.reconcile_day_event_selection(source);
 +        let Some(selected_id) = self.selected_day_event_id.as_deref() else {
 +            return;
 +        };
 +        if let Some(event) = selectable_day_events(self.selected_date, source)
 +            .into_iter()
 +            .find(|event| event.id == selected_id)
 +        {
 +            self.copy_choice = Some(EventCopyChoice::for_event(&event));
 +        }
 +    }
++
 +    pub fn select_day_event_id(&mut self, event_id: impl Into<String>) {
 +        if self.view_mode == ViewMode::Day {
 +            self.selected_day_event_id = Some(event_id.into());
 +        }
 +    }
++
      fn weekday_in_selected_week(&self, weekday: Weekday) -> Option<CalendarDate> {
          let month = self.calendar_month();
          let selected = month.selected_cell()?;
      CloseDay,
      OpenCreate,
      OpenDelete,
 +    OpenCopy,
      OpenHelp,
      Quit,
+ }
      Submit(EventDeleteSubmission),
+ }
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct EventCopyChoice {
 +    target: EventCopyTarget,
 +    selected: usize,
 +    error: Option<String>,
 +}
++
 +impl EventCopyChoice {
 +    fn for_event(event: &Event) -> Self {
 +        let target = if let Some(occurrence) = event.occurrence() {
 +            EventCopyTarget::Occurrence {
 +                series_id: occurrence.series_id.clone(),
 +                anchor: occurrence.anchor,
 +            }
 +        } else {
 +            EventCopyTarget::Event {
 +                event_id: event.id.clone(),
 +            }
 +        };
++
 +        Self {
 +            target,
 +            selected: 0,
 +            error: None,
 +        }
 +    }
++
 +    pub fn heading(&self) -> &'static str {
 +        "Copy"
 +    }
++
 +    pub fn error(&self) -> Option<&str> {
 +        self.error.as_deref()
 +    }
++
 +    pub fn rows(&self) -> Vec<EventCopyChoiceRow> {
 +        self.actions()
 +            .into_iter()
 +            .enumerate()
 +            .map(|(index, action)| EventCopyChoiceRow {
 +                label: action.label(),
 +                selected: index == self.selected,
 +            })
 +            .collect()
 +    }
++
 +    fn actions(&self) -> Vec<EventCopyChoiceAction> {
 +        match self.target {
 +            EventCopyTarget::Event { .. } => {
 +                vec![
 +                    EventCopyChoiceAction::CopyEvent,
 +                    EventCopyChoiceAction::Cancel,
 +                ]
 +            }
 +            EventCopyTarget::Occurrence { .. } => vec![
 +                EventCopyChoiceAction::CopyThisOccurrence,
 +                EventCopyChoiceAction::CopySeries,
 +                EventCopyChoiceAction::Cancel,
 +            ],
 +        }
 +    }
++
 +    fn selected_action(&self) -> EventCopyChoiceAction {
 +        self.actions()[self.selected]
 +    }
++
 +    fn select_next(&mut self) {
 +        let len = self.actions().len();
 +        self.selected = (self.selected + 1) % len;
 +        self.error = None;
 +    }
++
 +    fn select_previous(&mut self) {
 +        let len = self.actions().len();
 +        self.selected = if self.selected == 0 {
 +            len - 1
 +        } else {
 +            self.selected - 1
 +        };
 +        self.error = None;
 +    }
++
 +    fn event_id(&self) -> &str {
 +        match &self.target {
 +            EventCopyTarget::Event { event_id } => event_id,
 +            EventCopyTarget::Occurrence { series_id, .. } => series_id,
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +enum EventCopyTarget {
 +    Event {
 +        event_id: String,
 +    },
 +    Occurrence {
 +        series_id: String,
 +        anchor: OccurrenceAnchor,
 +    },
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub struct EventCopyChoiceRow {
 +    pub label: &'static str,
 +    pub selected: bool,
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +enum EventCopyChoiceAction {
 +    CopyEvent,
 +    CopyThisOccurrence,
 +    CopySeries,
 +    Cancel,
 +}
++
 +impl EventCopyChoiceAction {
 +    const fn label(self) -> &'static str {
 +        match self {
 +            Self::CopyEvent => "Copy event",
 +            Self::CopyThisOccurrence => "Copy this occurrence",
 +            Self::CopySeries => "Copy series",
 +            Self::Cancel => "Cancel",
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum EventCopySubmission {
 +    Event {
 +        event_id: String,
 +    },
 +    Occurrence {
 +        series_id: String,
 +        anchor: OccurrenceAnchor,
 +    },
 +    Series {
 +        series_id: String,
 +    },
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum EventCopyInputResult {
 +    Continue,
 +    Cancel,
 +    Submit(EventCopySubmission),
 +}
++
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub enum HelpInputResult {
      Continue,
              return AppAction::OpenDelete;
+         }
 +        if value.eq_ignore_ascii_case(&'c') {
 +            self.clear();
 +            return AppAction::OpenCopy;
 +        }
++
          if value.is_ascii_digit() {
              return self.translate_digit(value);
+         }
          );
+     }
 +    #[test]
 +    fn day_view_c_opens_copy_choice_for_selected_local_event() {
 +        let day = date(2026, Month::April, 23);
 +        let source = InMemoryAgendaSource::with_events_and_holidays(
 +            vec![local_timed_event(
 +                "local-time",
 +                "Standup",
 +                at(day, 9, 0),
 +                at(day, 9, 30),
 +            )],
 +            Vec::new(),
 +        );
 +        let mut app = AppState::new(day);
 +        let mut input = KeyboardInput::default();
++
 +        apply_keys_with_source(
 +            &mut app,
 +            &mut input,
 +            &source,
 +            [key(KeyCode::Enter), char_key('c')],
 +        );
++
 +        let choice = app.copy_choice().expect("copy modal opens");
 +        assert_eq!(choice.rows()[0].label, "Copy event");
 +        assert_eq!(
 +            app.handle_copy_choice_key(key(KeyCode::Enter)),
 +            EventCopyInputResult::Submit(EventCopySubmission::Event {
 +                event_id: "local-time".to_string()
 +            })
 +        );
 +    }
++
 +    #[test]
 +    fn day_view_c_opens_recurring_copy_choices() {
 +        let day = date(2026, Month::April, 23);
 +        let event = local_timed_event("series", "Standup", at(day, 9, 0), at(day, 9, 30))
 +            .with_recurrence(RecurrenceRule {
 +                frequency: RecurrenceFrequency::Daily,
 +                interval: 1,
 +                end: RecurrenceEnd::Count(2),
 +                weekdays: Vec::new(),
 +                monthly: None,
 +                yearly: None,
 +            });
 +        let source = InMemoryAgendaSource::with_events_and_holidays(vec![event], Vec::new());
 +        let mut app = AppState::new(day);
 +        let mut input = KeyboardInput::default();
++
 +        apply_keys_with_source(
 +            &mut app,
 +            &mut input,
 +            &source,
 +            [key(KeyCode::Enter), char_key('c')],
 +        );
++
 +        let choice = app.copy_choice().expect("copy modal opens");
 +        let rows = choice.rows();
 +        assert_eq!(rows[0].label, "Copy this occurrence");
 +        assert_eq!(rows[1].label, "Copy series");
 +        assert_eq!(
 +            app.handle_copy_choice_key(key(KeyCode::Enter)),
 +            EventCopyInputResult::Submit(EventCopySubmission::Occurrence {
 +                series_id: "series".to_string(),
 +                anchor: OccurrenceAnchor::Timed {
 +                    start: at(day, 9, 0)
 +                },
 +            })
 +        );
 +        assert_eq!(
 +            app.handle_copy_choice_key(key(KeyCode::Down)),
 +            EventCopyInputResult::Continue
 +        );
 +        assert_eq!(
 +            app.handle_copy_choice_key(key(KeyCode::Enter)),
 +            EventCopyInputResult::Submit(EventCopySubmission::Series {
 +                series_id: "series".to_string()
 +            })
 +        );
 +    }
++
      #[test]
      fn delete_choice_up_and_down_do_not_change_day_event_selection() {
          let day = date(2026, Month::April, 23);

src/cli.rsmodified

  use crate::{
      agenda::{ConfiguredAgendaSource, HolidayProvider, LocalEventStoreError, default_events_file},
      app::{
 -        AppState, CreateEventInputResult, EventDeleteInputResult, EventDeleteSubmission,
 -        EventFormMode, HelpInputResult, KeyboardInput, MouseInput, RecurrenceChoiceInputResult,
 +        AppState, CreateEventInputResult, EventCopyInputResult, EventCopySubmission,
 +        EventDeleteInputResult, EventDeleteSubmission, EventFormMode, HelpInputResult,
 +        KeyboardInput, MouseInput, RecurrenceChoiceInputResult,
      },
      calendar::CalendarDate,
      tui::{
      "  Arrow keys move selection; Enter opens day view; Esc returns to month; q exits.\n",
      "  ? opens contextual help.\n",
      "  + opens the Create event modal.\n",
 +    "  In day view, c opens the Copy confirmation for the selected local event.\n",
      "  In day view, d opens the Delete confirmation for the selected local event.\n",
      "  In day view, Left/Right move to the previous or next day.\n",
      "  Digits jump immediately; a quick second digit refines the selected day.\n",
          let event = if !app.is_creating_event()
              && !app.is_choosing_recurring_edit()
              && !app.is_confirming_delete()
 +            && !app.is_copying_event()
              && !app.is_showing_help()
              && keyboard.is_waiting_for_digit()
+         {
+                             }
                          },
+                     }
 +                } else if app.is_copying_event() {
 +                    match app.handle_copy_choice_key(key) {
 +                        EventCopyInputResult::Continue => {}
 +                        EventCopyInputResult::Cancel => app.close_copy_choice(),
 +                        EventCopyInputResult::Submit(submission) => {
 +                            let result = match submission {
 +                                EventCopySubmission::Event { event_id }
 +                                | EventCopySubmission::Series {
 +                                    series_id: event_id,
 +                                } => agenda_source.duplicate_event(&event_id),
 +                                EventCopySubmission::Occurrence { series_id, anchor } => {
 +                                    agenda_source.duplicate_occurrence(&series_id, anchor)
 +                                }
 +                            };
 +                            match result {
 +                                Ok(event) => {
 +                                    app.close_copy_choice();
 +                                    app.select_day_event_id(event.id);
 +                                    app.reconcile_day_event_selection(&agenda_source);
 +                                }
 +                                Err(err) => app.set_copy_error(err.to_string()),
 +                            }
 +                        }
 +                    }
                  } else if app.is_choosing_recurring_edit() {
                      match app.handle_recurrence_choice_key(key, &agenda_source) {
                          RecurrenceChoiceInputResult::Continue => {}
                  if app.is_creating_event()
                      || app.is_choosing_recurring_edit()
                      || app.is_confirming_delete()
 +                    || app.is_copying_event()
                      || app.is_showing_help()
+                 {
                      continue;

src/tui.rsmodified

          AgendaSource, DayAgenda, DayMinute, EmptyAgendaSource, Event, EventTiming, TimedAgendaEvent,
      },
      app::{
 -        AppState, CreateEventForm, CreateEventFormRowKind, EventDeleteChoice, RecurrenceEditChoice,
 -        ViewMode,
 +        AppState, CreateEventForm, CreateEventFormRowKind, EventCopyChoice, EventDeleteChoice,
 +        RecurrenceEditChoice, ViewMode,
      },
      calendar::{
          CalendarCell, CalendarDate, CalendarMonth, CalendarWeek, DAYS_PER_WEEK, MONTH_GRID_WEEKS,
          if let Some(choice) = self.app.delete_choice() {
              render_delete_choice_modal(choice, area, buf, CreateModalStyles::new());
+         }
 +        if let Some(choice) = self.app.copy_choice() {
 +            render_copy_choice_modal(choice, area, buf, CreateModalStyles::new());
 +        }
          if self.app.is_showing_help() {
              render_help_modal(self.app.view_mode(), area, buf, CreateModalStyles::new());
+         }
      );
+ }
 +fn render_copy_choice_modal(
 +    choice: &EventCopyChoice,
 +    area: Rect,
 +    buf: &mut Buffer,
 +    styles: CreateModalStyles,
 +) {
 +    if area.width == 0 || area.height == 0 {
 +        return;
 +    }
++
 +    let modal = recurrence_choice_modal_area(area);
 +    fill_rect(buf, modal, styles.panel);
 +    draw_border(buf, modal, styles.border, BorderCharacters::normal());
++
 +    let content = inset_rect(modal);
 +    if content.width == 0 || content.height == 0 {
 +        return;
 +    }
++
 +    write_centered(
 +        buf,
 +        content.y,
 +        content.x,
 +        content.width,
 +        choice.heading(),
 +        styles.title,
 +    );
++
 +    let mut y = content.y.saturating_add(2);
 +    for row in choice.rows() {
 +        if y >= content.bottom().saturating_sub(2) {
 +            break;
 +        }
 +        let marker = if row.selected { ">" } else { " " };
 +        write_padded_left(buf, y, content.x, 1, marker, styles.label);
 +        write_left(
 +            buf,
 +            y,
 +            content.x.saturating_add(2),
 +            content.width.saturating_sub(2),
 +            row.label,
 +            if row.selected {
 +                styles.title
 +            } else {
 +                styles.value
 +            },
 +        );
 +        y = y.saturating_add(1);
 +    }
++
 +    if let Some(error) = choice.error() {
 +        write_left(
 +            buf,
 +            content.bottom().saturating_sub(2),
 +            content.x,
 +            content.width,
 +            error,
 +            styles.error,
 +        );
 +    }
++
 +    write_centered(
 +        buf,
 +        content.bottom().saturating_sub(1),
 +        content.x,
 +        content.width,
 +        "Enter select | Esc cancel",
 +        styles.footer,
 +    );
 +}
++
  fn render_help_modal(view_mode: ViewMode, area: Rect, buf: &mut Buffer, styles: CreateModalStyles) {
      if area.width == 0 || area.height == 0 {
          return;
              ("Left/Right", "Move to the previous or next day"),
              ("Up/Down", "Select a local event"),
              ("Enter", "Edit the selected local event"),
 +            ("c", "Copy the selected local event"),
              ("d", "Delete the selected local event"),
              ("+", "Create an event on this day"),
              ("Esc", "Return to month view"),
          assert!(rendered.contains("Enter select"));
+     }
 +    #[test]
 +    fn copy_choice_modal_renders_over_day_view() {
 +        let day = date(2026, Month::April, 23);
 +        let source = agenda_source(
 +            vec![local_timed_event(
 +                "planning",
 +                "Planning",
 +                at(day, 9, 0),
 +                at(day, 10, 0),
 +            )],
 +            Vec::new(),
 +        );
 +        let mut app = AppState::new(day);
 +        app.apply_with_agenda_source(AppAction::OpenDay, &source);
 +        app.apply_with_agenda_source(AppAction::OpenCopy, &source);
++
 +        let rendered = render_app_to_string_with_agenda_source(&app, 84, 26, &source);
++
 +        assert!(rendered.contains("Copy"));
 +        assert!(rendered.contains("Copy event"));
 +        assert!(rendered.contains("Enter select"));
 +    }
++
      #[test]
      fn help_modal_shows_month_week_keys_in_month_mode() {
          let mut app = AppState::new(date(2026, Month::April, 23));
          let rendered = render_app_to_string(&app, 84, 26);
          assert!(rendered.contains("Day keys"));
 +        assert!(rendered.contains("Copy the selected local event"));
          assert!(rendered.contains("Delete the selected local event"));
          assert!(rendered.contains("Move to the previous or next day"));
+     }