Calendar deduping for issue 74 implemented

Author: jherforth

client/src/components/CalendarWidget.jsx

@@ -187,6 +187,7 @@ const CalendarWidget = ({
   const [calendarSettingsLoaded, setCalendarSettingsLoaded] = useState(false);
   const [showColorPicker, setShowColorPicker] = useState({ background: false, text: false });
   const [calendarSources, setCalendarSources] = useState([]);
+  const [dedupEnabled, setDedupEnabled] = useState(false);
   const [showCalendarDialog, setShowCalendarDialog] = useState(false);
   const [editingCalendar, setEditingCalendar] = useState(null);
   const [calendarForm, setCalendarForm] = useState({
@@ -237,6 +238,7 @@ const CalendarWidget = ({
     fetchCalendarSources();
     fetchCalendarEvents();
     fetchSyncStatus();
+    fetchDedupSetting();
   }, []);
 
   // Auto-refresh functionality
@@ -403,6 +405,30 @@ const CalendarWidget = ({
     }
   };
 
+  const fetchDedupSetting = async () => {
+    try {
+      const response = await axios.get(`${API_BASE_URL}/api/settings`);
+      setDedupEnabled(response.data?.CALENDAR_DEDUP_ENABLED === 'true');
+    } catch (error) {
+      console.error('Error fetching dedup setting:', error);
+    }
+  };
+
+  const handleToggleDedup = async (event) => {
+    const enabled = event.target.checked;
+    setDedupEnabled(enabled);
+    try {
+      await axios.post(`${API_BASE_URL}/api/settings`, {
+        key: 'CALENDAR_DEDUP_ENABLED',
+        value: enabled ? 'true' : 'false',
+      });
+      await fetchCalendarEvents();
+    } catch (error) {
+      console.error('Error saving dedup setting:', error);
+      setDedupEnabled(!enabled); // revert on failure
+    }
+  };
+
   const fetchSyncStatus = async () => {
     try {
       const response = await axios.get(`${API_BASE_URL}/api/calendar-sync/status`);
@@ -1965,6 +1991,17 @@ const CalendarWidget = ({
 
           <Divider sx={{ my: 2 }} />
 
+          <FormControlLabel
+            control={<Switch checked={dedupEnabled} onChange={handleToggleDedup} />}
+            label="Merge duplicate events across calendars"
+          />
+          <Typography variant="caption" color="text.secondary" sx={{ display: 'block', mb: 1 }}>
+            When the same event appears on more than one calendar (even with slightly
+            different titles), show it only once.
+          </Typography>
+
+          <Divider sx={{ my: 2 }} />
+
           <Typography variant="h6" sx={{ mb: 2 }}>Tab specific settings</Typography>
 
           <Box sx={{ mb: 2 }}>

server/services/calendarSync.js

@@ -4,6 +4,7 @@ const node_ical = require('node-ical');
 const googleConnection = require('./googleConnection');
 const googleCalendar = require('./googleCalendar');
 const appleCalDAV = require('./appleCalDAV');
+const { dedupeCalendarEvents } = require('../utils/calendarDedup');
 
 class CalendarSyncService {
   constructor(db, decryptPassword) {
@@ -286,7 +287,7 @@ class CalendarSyncService {
 
     const rows = this.db.prepare(query).all(...params);
 
-    return rows.map(row => {
+    const events = rows.map(row => {
       const source = sourceMap.get(row.source_id);
       return {
         id: row.event_uid,
@@ -301,6 +302,22 @@ class CalendarSyncService {
         source_color: source?.color || '#6e44ff'
       };
     });
+
+    // Opt-in: merge the same event synced from multiple calendars (off by
+    // default so no events silently disappear for existing installs).
+    if (this.isDedupEnabled()) {
+      return dedupeCalendarEvents(events);
+    }
+    return events;
+  }
+
+  isDedupEnabled() {
+    try {
+      const row = this.db.prepare("SELECT value FROM settings WHERE key = 'CALENDAR_DEDUP_ENABLED'").get();
+      return row?.value === 'true';
+    } catch {
+      return false;
+    }
   }
 
   getSyncStatus(sourceId) {

server/tests/calendarDedup.test.js

@@ -0,0 +1,104 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { dedupeCalendarEvents, normalizeTitle, titleSimilarity } = require('../utils/calendarDedup');
+
+const BASE = new Date('2026-07-10T15:00:00.000Z').getTime();
+
+function ev(id, sourceId, sourceName, title, startOffsetMin = 0, durationMin = 60) {
+  const start = new Date(BASE + startOffsetMin * 60000);
+  const end = new Date(start.getTime() + durationMin * 60000);
+  return { id, source_id: sourceId, source_name: sourceName, title, start, end };
+}
+
+test('normalizeTitle strips calendar prefix, punctuation, and case', () => {
+  assert.equal(normalizeTitle('[Family] Soccer Practice!'), 'soccer practice');
+  assert.equal(normalizeTitle('(Work)  Stand-up'), 'stand up');
+  assert.equal(normalizeTitle(null), '');
+});
+
+test('titleSimilarity: containment and exact match score 1', () => {
+  assert.equal(titleSimilarity('Soccer', 'Soccer practice'), 1);
+  assert.equal(titleSimilarity('Dentist', 'dentist'), 1);
+  assert.ok(titleSimilarity('Dentist', 'Soccer') < 0.3);
+});
+
+test('merges the same event across two different sources', () => {
+  const events = [
+    ev('a1', 1, 'Family ICS', 'Soccer practice'),
+    ev('a2', 2, 'Google', 'Soccer Practice - City Fields', 2),
+  ];
+  const out = dedupeCalendarEvents(events);
+  assert.equal(out.length, 1);
+  assert.equal(out[0].source_id, 1, 'lowest source_id survives');
+  assert.equal(out[0].title, 'Soccer practice');
+  assert.deepEqual(out[0].merged_from, [{ source_id: 2, source_name: 'Google' }]);
+});
+
+test('never merges two events from the same source', () => {
+  const events = [
+    ev('d1', 1, 'Family ICS', 'Dishes'),
+    ev('d2', 1, 'Family ICS', 'Dishes'),
+  ];
+  const out = dedupeCalendarEvents(events);
+  assert.equal(out.length, 2);
+  assert.ok(!out.some((e) => e.merged_from));
+});
+
+test('does not merge same title at clearly different times', () => {
+  const events = [
+    ev('b1', 1, 'Family ICS', 'Dentist', 0),
+    ev('c1', 2, 'Google', 'Dentist', 120), // 2 hours later
+  ];
+  const out = dedupeCalendarEvents(events);
+  assert.equal(out.length, 2);
+});
+
+test('does not merge different events at the same time', () => {
+  const events = [
+    ev('x1', 1, 'Family ICS', 'Piano lesson'),
+    ev('y1', 2, 'Google', 'Grocery run'),
+  ];
+  const out = dedupeCalendarEvents(events);
+  assert.equal(out.length, 2);
+});
+
+test('merges a 3-source cluster into one survivor listing both others', () => {
+  const events = [
+    ev('t3', 3, 'Apple', 'Team meeting', 1),
+    ev('t1', 1, 'Family ICS', 'Team meeting'),
+    ev('t2', 2, 'Google', 'Team Meeting', 3),
+  ];
+  const out = dedupeCalendarEvents(events);
+  assert.equal(out.length, 1);
+  assert.equal(out[0].source_id, 1);
+  assert.deepEqual(
+    out[0].merged_from.map((m) => m.source_id),
+    [2, 3]
+  );
+});
+
+test('respects the time tolerance boundary', () => {
+  const withinTol = [ev('w1', 1, 'A', 'Event'), ev('w2', 2, 'B', 'Event', 4)];
+  assert.equal(dedupeCalendarEvents(withinTol).length, 1, '4 min apart merges');
+
+  const outsideTol = [ev('o1', 1, 'A', 'Event'), ev('o2', 2, 'B', 'Event', 10)];
+  assert.equal(dedupeCalendarEvents(outsideTol).length, 2, '10 min apart does not');
+});
+
+test('output stays sorted by start time and does not mutate input', () => {
+  const events = [
+    ev('late', 1, 'A', 'Late thing', 120),
+    ev('early', 2, 'B', 'Early thing', 0),
+  ];
+  const snapshot = JSON.stringify(events);
+  const out = dedupeCalendarEvents(events);
+  assert.equal(out[0].id, 'early');
+  assert.equal(out[1].id, 'late');
+  assert.equal(JSON.stringify(events), snapshot, 'input array/objects unchanged');
+});
+
+test('passes through arrays of 0 or 1 event unchanged', () => {
+  assert.deepEqual(dedupeCalendarEvents([]), []);
+  const one = [ev('solo', 1, 'A', 'Solo')];
+  assert.equal(dedupeCalendarEvents(one).length, 1);
+});

server/utils/calendarDedup.js

@@ -0,0 +1,122 @@
+// Deduplicate calendar events that represent the same real-world event synced
+// from more than one calendar source (e.g. a shared event that lives on both a
+// family ICS feed and a personal Google calendar, sometimes with slightly
+// different titles). This is a pure, read-time merge — it never touches the
+// per-source cache, so editing/deleting still targets the surviving event's
+// real (source_id, id).
+
+// Two events count as "the same time" when both start and end are within this
+// tolerance. Absorbs small timezone/DST/all-day offsets between sources.
+const DEFAULT_TIME_TOLERANCE_MS = 5 * 60 * 1000;
+
+// Dice-coefficient title similarity above this counts as a match (0..1).
+const DEFAULT_SIMILARITY_THRESHOLD = 0.6;
+
+// Lowercase, drop a leading "[Family] " / "(Work) " calendar prefix, replace
+// punctuation with spaces, collapse whitespace.
+function normalizeTitle(title) {
+  if (typeof title !== 'string') return '';
+  return title
+    .toLowerCase()
+    .replace(/^\s*[[(][^\])]*[\])]\s*/, '')
+    .replace(/[^\p{L}\p{N}\s]/gu, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function bigramCounts(str) {
+  const counts = new Map();
+  for (let i = 0; i < str.length - 1; i++) {
+    const bg = str.slice(i, i + 2);
+    counts.set(bg, (counts.get(bg) || 0) + 1);
+  }
+  return counts;
+}
+
+// Sørensen–Dice coefficient over character bigrams. Robust to minor edits and
+// word reordering; returns 1 for equality or when one title contains the other
+// ("Soccer" vs "Soccer practice").
+function titleSimilarity(a, b) {
+  const na = normalizeTitle(a);
+  const nb = normalizeTitle(b);
+  if (!na && !nb) return 1;
+  if (!na || !nb) return 0;
+  if (na === nb) return 1;
+  if (na.includes(nb) || nb.includes(na)) return 1;
+  if (na.length < 2 || nb.length < 2) return 0;
+
+  const A = bigramCounts(na);
+  const B = bigramCounts(nb);
+  let overlap = 0;
+  let sizeA = 0;
+  let sizeB = 0;
+  for (const c of A.values()) sizeA += c;
+  for (const c of B.values()) sizeB += c;
+  for (const [bg, countA] of A) {
+    overlap += Math.min(countA, B.get(bg) || 0);
+  }
+  return (2 * overlap) / (sizeA + sizeB);
+}
+
+function timesMatch(a, b, toleranceMs) {
+  const startDiff = Math.abs(new Date(a.start).getTime() - new Date(b.start).getTime());
+  const endDiff = Math.abs(new Date(a.end).getTime() - new Date(b.end).getTime());
+  return startDiff <= toleranceMs && endDiff <= toleranceMs;
+}
+
+// Merge duplicate events. Returns a new array (input is not mutated). Events
+// only merge across *different* sources; the survivor is the copy from the
+// lowest source_id, with a `merged_from: [{source_id, source_name}]` list of
+// the sources it absorbed. Output is sorted by start time (source_id tiebreak).
+function dedupeCalendarEvents(events, options = {}) {
+  if (!Array.isArray(events) || events.length < 2) {
+    return Array.isArray(events) ? events.slice() : events;
+  }
+
+  const toleranceMs = options.toleranceMs ?? DEFAULT_TIME_TOLERANCE_MS;
+  const threshold = options.similarityThreshold ?? DEFAULT_SIMILARITY_THRESHOLD;
+
+  const clusters = [];
+  for (const event of events) {
+    let cluster = null;
+    for (const c of clusters) {
+      // Never merge two events from the same source.
+      if (c.sourceIds.has(event.source_id)) continue;
+      if (!timesMatch(c.survivor, event, toleranceMs)) continue;
+      if (titleSimilarity(c.survivor.title, event.title) < threshold) continue;
+      cluster = c;
+      break;
+    }
+
+    if (!cluster) {
+      clusters.push({ survivor: event, absorbed: [], sourceIds: new Set([event.source_id]) });
+      continue;
+    }
+
+    cluster.sourceIds.add(event.source_id);
+    // Deterministic survivor: lowest source_id wins.
+    if (event.source_id < cluster.survivor.source_id) {
+      cluster.absorbed.push(cluster.survivor);
+      cluster.survivor = event;
+    } else {
+      cluster.absorbed.push(event);
+    }
+  }
+
+  const output = clusters.map((c) => {
+    const survivor = { ...c.survivor };
+    if (c.absorbed.length > 0) {
+      survivor.merged_from = c.absorbed
+        .map((e) => ({ source_id: e.source_id, source_name: e.source_name }))
+        .sort((x, y) => x.source_id - y.source_id);
+    }
+    return survivor;
+  });
+
+  output.sort(
+    (a, b) => new Date(a.start).getTime() - new Date(b.start).getTime() || a.source_id - b.source_id
+  );
+  return output;
+}
+
+module.exports = { dedupeCalendarEvents, normalizeTitle, titleSimilarity };