fix: Improve Date Parsing Robustness in NLP Fallback

js/utils/nlpDateExtractor.js

@@ -99,10 +99,20 @@ function matchInNDaysWeeks(lower, now) {
 const WEEKDAYS = ['sunday','monday','tuesday','wednesday','thursday','friday','saturday'];
 
 function matchNamedWeekday(lower, now) {
+  let m = lower.match(new RegExp(`\\bfirst\\s+(${WEEKDAYS.join('|')})\\s+of\\s+next\\s+month\\b`));
+  if (m) {
+    const target = WEEKDAYS.indexOf(m[1]);
+    const d = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+    let diff = target - d.getDay();
+    if (diff < 0) diff += 7;
+    d.setDate(d.getDate() + diff);
+    return toISO(startOf(d));
+  }
+
   const pattern = new RegExp(
     `\\b(next|this|on|coming)?\\s*(${WEEKDAYS.join('|')})\\b`
   );
-  const m = lower.match(pattern);
+  m = lower.match(pattern);
   if (!m) return null;
 
   const qualifier = m[1] || '';
@@ -151,31 +161,62 @@ function matchAbsoluteDate(lower, now) {
   if (m) {
     const month = MONTHS[m[1]];
     const day = parseInt(m[2]);
-    return toISO(startOf(resolveYear(now, month, day)));
+    const resolved = resolveYear(now, month, day);
+    if (resolved) return toISO(startOf(resolved));
   }
 
   m = lower.match(new RegExp(`\\b${ordinal}\\s+(${monthNames})\\b`));
   if (m) {
     const day = parseInt(m[1]);
     const month = MONTHS[m[2]];
-    return toISO(startOf(resolveYear(now, month, day)));
+    const resolved = resolveYear(now, month, day);
+    if (resolved) return toISO(startOf(resolved));
+  }
+
+  m = lower.match(new RegExp(`\\bmid[-\\s](${monthNames})\\b`));
+  if (m) {
+    const resolved = resolveYear(now, MONTHS[m[1]], 15);
+    if (resolved) return toISO(startOf(resolved));
   }
 
   m = lower.match(/\b(\d{1,2})[\/\-\.](\d{1,2})(?:[\/\-\.](\d{2,4}))?\b/);
   if (m) {
-    const day = parseInt(m[1]);
-    const month = parseInt(m[2]) - 1;
+    const p1 = parseInt(m[1]);
+    const p2 = parseInt(m[2]);
+    let month, day;
+    if (p1 > 12 && p2 <= 12) {
+      day = p1;
+      month = p2 - 1;
+    } else {
+      month = p1 - 1;
+      day = p2;
+    }
     const year = m[3] ? (m[3].length === 2 ? 2000 + parseInt(m[3]) : parseInt(m[3])) : null;
-    return toISO(startOf(resolveYear(now, month, day, year)));
+    const resolved = resolveYear(now, month, day, year);
+    if (resolved) return toISO(startOf(resolved));
   }
 
   return null;
 }
 
+export function isValidDate(year, month, day) {
+  const d = new Date(year, month, day);
+  return d.getFullYear() === year && d.getMonth() === month && d.getDate() === day;
+}
+
 function resolveYear(now, month, day, explicitYear = null) {
-  if (explicitYear) return new Date(explicitYear, month, day);
-  const candidate = new Date(now.getFullYear(), month, day);
-  if (candidate < now) candidate.setFullYear(candidate.getFullYear() + 1);
+  if (explicitYear) {
+    if (!isValidDate(explicitYear, month, day)) return null;
+    return new Date(explicitYear, month, day);
+  }
+  let y = now.getFullYear();
+  if (!isValidDate(y, month, day)) return null;
+  const candidate = new Date(y, month, day);
+  if (candidate < now) {
+    y += 1;
+    if (!isValidDate(y, month, day)) return null;
+    candidate.setFullYear(y);
+  }
   return candidate;
 }
 
@@ -190,6 +231,10 @@ function matchEndOfPeriod(lower, now) {
     const d = new Date(now.getFullYear(), now.getMonth() + 1, 0); // last day of month
     return toISO(startOf(d));
   }
+  if (/\bbeginning of (next\s+)?month\b/.test(lower)) {
+    const d = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+    return toISO(startOf(d));
+  }
   if (/\bend of (the\s+)?year\b/.test(lower)) {
     const d = new Date(now.getFullYear(), 11, 31);
     return toISO(startOf(d));

server.js

@@ -74,10 +74,24 @@ const NLP_MONTHS = {
   oct:9,october:9,nov:10,november:10,dec:11,december:11
 };
 
+function isValidDate(year, month, day) {
+  const d = new Date(year, month, day);
+  return d.getFullYear() === year && d.getMonth() === month && d.getDate() === day;
+}
+
 function nlpResolveYear(now, month, day, explicitYear = null) {
-  if (explicitYear) return new Date(explicitYear, month, day);
-  const c = new Date(now.getFullYear(), month, day);
-  if (c < now) c.setFullYear(c.getFullYear() + 1);
+  if (explicitYear) {
+    if (!isValidDate(explicitYear, month, day)) return null;
+    return new Date(explicitYear, month, day);
+  }
+  let y = now.getFullYear();
+  if (!isValidDate(y, month, day)) return null;
+  const c = new Date(y, month, day);
+  if (c < now) {
+    y += 1;
+    if (!isValidDate(y, month, day)) return null;
+    c.setFullYear(y);
+  }
   return c;
 }
 
@@ -113,27 +127,62 @@ function nlpExtractDate(text, now = new Date()) {
   const monthNames = Object.keys(NLP_MONTHS).join('|');
   const ord = `(\\d{1,2})(?:st|nd|rd|th)?`;
   m = lower.match(new RegExp(`\\b(${monthNames})\\s+${ord}\\b`));
-  if (m) return nlpWithTime(nlpStartOf(nlpResolveYear(now, NLP_MONTHS[m[1]], parseInt(m[2]))).toISOString(), time);
+  if (m) {
+    const resolved = nlpResolveYear(now, NLP_MONTHS[m[1]], parseInt(m[2]));
+    if (resolved) return nlpWithTime(nlpStartOf(resolved).toISOString(), time);
+  }
+
   m = lower.match(new RegExp(`\\b${ord}\\s+(${monthNames})\\b`));
-  if (m) return nlpWithTime(nlpStartOf(nlpResolveYear(now, NLP_MONTHS[m[2]], parseInt(m[1]))).toISOString(), time);
+  if (m) {
+    const resolved = nlpResolveYear(now, NLP_MONTHS[m[2]], parseInt(m[1]));
+    if (resolved) return nlpWithTime(nlpStartOf(resolved).toISOString(), time);
+  }
+
+  m = lower.match(new RegExp(`\\bmid[-\\s](${monthNames})\\b`));
+  if (m) {
+    const resolved = nlpResolveYear(now, NLP_MONTHS[m[1]], 15);
+    if (resolved) return nlpWithTime(nlpStartOf(resolved).toISOString(), time);
+  }
+
+  m = lower.match(new RegExp(`\\bfirst\\s+(${NLP_WEEKDAYS.join('|')})\\s+of\\s+next\\s+month\\b`));
+  if (m) {
+    const target = NLP_WEEKDAYS.indexOf(m[1]);
+    const d = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+    let diff = target - d.getDay();
+    if (diff < 0) diff += 7;
+    d.setDate(d.getDate() + diff);
+    return nlpWithTime(nlpStartOf(d).toISOString(), time);
+  }
 
   m = lower.match(/\b(\d{1,2})[\/\-\.](\d{1,2})(?:[\/\-\.](\d{2,4}))?\b/);
   if (m) {
-    const day = parseInt(m[1]), month = parseInt(m[2]) - 1;
+    let p1 = parseInt(m[1]), p2 = parseInt(m[2]);
+    let month, day;
+    if (p1 > 12 && p2 <= 12) {
+      day = p1;
+      month = p2 - 1;
+    } else {
+      month = p1 - 1;
+      day = p2;
+    }
     const yr = m[3] ? (m[3].length === 2 ? 2000 + parseInt(m[3]) : parseInt(m[3])) : null;
-    return nlpWithTime(nlpStartOf(nlpResolveYear(now, month, day, yr)).toISOString(), time);
+    const resolved = nlpResolveYear(now, month, day, yr);
+    if (resolved) return nlpWithTime(nlpStartOf(resolved).toISOString(), time);
   }
 
   if (/\bend of (the\s+)?week\b/.test(lower) || /\bby (the\s+)?weekend\b/.test(lower)) {
     const d = new Date(now); d.setDate(d.getDate() + (7 - d.getDay()));
-    return nlpStartOf(d).toISOString();
+    return nlpWithTime(nlpStartOf(d).toISOString(), time);
   }
   if (/\bend of (the\s+)?month\b/.test(lower)) {
-    return nlpStartOf(new Date(now.getFullYear(), now.getMonth() + 1, 0)).toISOString();
+    return nlpWithTime(nlpStartOf(new Date(now.getFullYear(), now.getMonth() + 1, 0)).toISOString(), time);
+  }
+  if (/\bbeginning of (next\s+)?month\b/.test(lower)) {
+    return nlpWithTime(nlpStartOf(new Date(now.getFullYear(), now.getMonth() + 1, 1)).toISOString(), time);
   }
   if (/\bnext month\b/.test(lower)) {
     const d = new Date(now); d.setMonth(d.getMonth() + 1);
-    return nlpStartOf(d).toISOString();
+    return nlpWithTime(nlpStartOf(d).toISOString(), time);
   }
 
   return null;

tests/nlpDate.test.js

@@ -0,0 +1,56 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+test('isValidDate validation', async () => {
+  const { isValidDate } = await import('../js/utils/nlpDateExtractor.js');
+  assert.equal(isValidDate(2023, 1, 28), true); // Feb 28
+  assert.equal(isValidDate(2023, 1, 29), false); // Feb 29 2023 (Not leap)
+  assert.equal(isValidDate(2024, 1, 29), true); // Feb 29 2024 (Leap)
+  assert.equal(isValidDate(2023, 3, 31), false); // Apr 31
+});
+
+test('Ambiguous Date Formats MM/DD/YYYY vs DD/MM/YYYY', async () => {
+  const { extractDate } = await import('../js/utils/nlpDateExtractor.js');
+  const now = new Date(2023, 0, 1);
+
+  // Default MM/DD/YYYY
+  const res1 = extractDate("The deadline is 03/04/2023", now);
+  // Expect March 4, 2023
+  assert.equal(new Date(res1).toISOString().startsWith('2023-03-04'), true);
+
+  // Fallback to DD/MM/YYYY when XX > 12
+  const res2 = extractDate("The deadline is 15/04/2023", now);
+  // Expect April 15, 2023
+  assert.equal(new Date(res2).toISOString().startsWith('2023-04-15'), true);
+});
+
+test('Natural Language Phrases', async () => {
+  const { extractDate } = await import('../js/utils/nlpDateExtractor.js');
+  const now = new Date(2023, 5, 10); // June 10, 2023
+
+  // Mid-month
+  const midJan = extractDate("Submit by mid-January", now);
+  assert.equal(new Date(midJan).toISOString().startsWith('2024-01-15'), true); // Next year Jan
+
+  const midJune = extractDate("Submit by mid-June", now);
+  assert.equal(new Date(midJune).toISOString().startsWith('2023-06-15'), true);
+
+  // Beginning of next month
+  const beginningNext = extractDate("due beginning of next month", now);
+  assert.equal(new Date(beginningNext).toISOString().startsWith('2023-07-01'), true);
+
+  // First Monday of next month
+  const firstMonNext = extractDate("due first Monday of next month", now);
+  // Next month is July 2023. July 1, 2023 is Saturday (day 6).
+  // First Monday should be July 3, 2023.
+  assert.equal(new Date(firstMonNext).toISOString().startsWith('2023-07-03'), true);
+});
+
+test('Graceful fallback for invalid parsed calendar dates', async () => {
+  const { extractDate } = await import('../js/utils/nlpDateExtractor.js');
+  const now = new Date(2023, 0, 1);
+
+  // February 30th is invalid, should return null (so fallback handles it in caller)
+  const invalidDate = extractDate("due on Feb 30", now);
+  assert.equal(invalidDate, null);
+});