claude-brain 0.30.2 → 0.30.3

package/src/retrieval/query/temporal-parser.ts

@@ -1,295 +1,295 @@
-/**
- * Temporal Parser
- * Parses temporal expressions in queries using compromise.js
- */
-
-import type { TemporalParse } from '../types'
-
-// Dynamic import for compromise to avoid bundling issues
-let nlp: any
-
-async function loadNlp(): Promise<any> {
-  if (!nlp) {
-    nlp = (await import('compromise')).default
-  }
-  return nlp
-}
-
-/** Relative time patterns */
-const RELATIVE_PATTERNS: Array<{
-  pattern: RegExp
-  parse: (match: RegExpMatchArray) => { start?: Date; end?: Date }
-}> = [
-  // "last N days/weeks/months/years"
-  {
-    pattern: /(?:in\s+the\s+)?last\s+(\d+)\s+(day|week|month|year)s?/i,
-    parse: (match) => {
-      const amount = parseInt(match[1]!, 10)
-      const unit = match[2]!.toLowerCase()
-      const now = new Date()
-      const start = new Date(now)
-
-      switch (unit) {
-        case 'day':
-          start.setDate(start.getDate() - amount)
-          break
-        case 'week':
-          start.setDate(start.getDate() - amount * 7)
-          break
-        case 'month':
-          start.setMonth(start.getMonth() - amount)
-          break
-        case 'year':
-          start.setFullYear(start.getFullYear() - amount)
-          break
-      }
-
-      return { start, end: now }
-    }
-  },
-  // "N days/weeks/months ago"
-  {
-    pattern: /(\d+)\s+(day|week|month|year)s?\s+ago/i,
-    parse: (match) => {
-      const amount = parseInt(match[1]!, 10)
-      const unit = match[2]!.toLowerCase()
-      const target = new Date()
-
-      switch (unit) {
-        case 'day':
-          target.setDate(target.getDate() - amount)
-          break
-        case 'week':
-          target.setDate(target.getDate() - amount * 7)
-          break
-        case 'month':
-          target.setMonth(target.getMonth() - amount)
-          break
-        case 'year':
-          target.setFullYear(target.getFullYear() - amount)
-          break
-      }
-
-      // For "X ago", use a range around that date (±1 day)
-      const start = new Date(target)
-      start.setDate(start.getDate() - 1)
-      const end = new Date(target)
-      end.setDate(end.getDate() + 1)
-
-      return { start, end }
-    }
-  },
-  // "this week/month/year"
-  {
-    pattern: /this\s+(week|month|year)/i,
-    parse: (match) => {
-      const unit = match[1]!.toLowerCase()
-      const now = new Date()
-      const start = new Date(now)
-
-      switch (unit) {
-        case 'week':
-          const day = start.getDay()
-          start.setDate(start.getDate() - day) // Start of week (Sunday)
-          break
-        case 'month':
-          start.setDate(1) // Start of month
-          break
-        case 'year':
-          start.setMonth(0, 1) // Start of year
-          break
-      }
-      start.setHours(0, 0, 0, 0)
-
-      return { start, end: now }
-    }
-  },
-  // "yesterday"
-  {
-    pattern: /yesterday/i,
-    parse: () => {
-      const yesterday = new Date()
-      yesterday.setDate(yesterday.getDate() - 1)
-      yesterday.setHours(0, 0, 0, 0)
-
-      const endOfYesterday = new Date(yesterday)
-      endOfYesterday.setHours(23, 59, 59, 999)
-
-      return { start: yesterday, end: endOfYesterday }
-    }
-  },
-  // "today"
-  {
-    pattern: /today/i,
-    parse: () => {
-      const today = new Date()
-      today.setHours(0, 0, 0, 0)
-
-      return { start: today, end: new Date() }
-    }
-  },
-  // "recent" / "recently" / "lately"
-  {
-    pattern: /recent(?:ly)?|lately/i,
-    parse: () => {
-      const now = new Date()
-      const start = new Date(now)
-      start.setDate(start.getDate() - 7) // Default "recent" to 7 days
-
-      return { start, end: now }
-    }
-  },
-  // "past week/month"
-  {
-    pattern: /past\s+(week|month|year)/i,
-    parse: (match) => {
-      const unit = match[1]!.toLowerCase()
-      const now = new Date()
-      const start = new Date(now)
-
-      switch (unit) {
-        case 'week':
-          start.setDate(start.getDate() - 7)
-          break
-        case 'month':
-          start.setMonth(start.getMonth() - 1)
-          break
-        case 'year':
-          start.setFullYear(start.getFullYear() - 1)
-          break
-      }
-
-      return { start, end: now }
-    }
-  },
-  // "since January" / "since 2024"
-  {
-    pattern: /since\s+(january|february|march|april|may|june|july|august|september|october|november|december|\d{4})/i,
-    parse: (match) => {
-      const value = match[1]!.toLowerCase()
-      const start = new Date()
-
-      // Check if it's a year
-      if (/^\d{4}$/.test(value)) {
-        start.setFullYear(parseInt(value, 10), 0, 1)
-      } else {
-        // It's a month
-        const months: Record<string, number> = {
-          january: 0, february: 1, march: 2, april: 3,
-          may: 4, june: 5, july: 6, august: 7,
-          september: 8, october: 9, november: 10, december: 11
-        }
-        const monthIndex = months[value]
-        if (monthIndex !== undefined) {
-          start.setMonth(monthIndex, 1)
-          // If the month is in the future, assume last year
-          if (start > new Date()) {
-            start.setFullYear(start.getFullYear() - 1)
-          }
-        }
-      }
-      start.setHours(0, 0, 0, 0)
-
-      return { start, end: new Date() }
-    }
-  }
-]
-
-/**
- * Parse temporal expressions from a query
- */
-export function parseTemporal(query: string): TemporalParse {
-  // Check each pattern
-  for (const { pattern, parse } of RELATIVE_PATTERNS) {
-    const match = query.match(pattern)
-    if (match) {
-      const { start, end } = parse(match)
-
-      // Remove temporal expression from query
-      const cleanedQuery = query.replace(pattern, '').replace(/\s+/g, ' ').trim()
-
-      return {
-        hasTemporal: true,
-        start,
-        end,
-        expression: match[0],
-        cleanedQuery
-      }
-    }
-  }
-
-  return {
-    hasTemporal: false,
-    cleanedQuery: query
-  }
-}
-
-/**
- * Parse temporal using compromise.js for more complex expressions
- * Falls back to regex patterns if compromise fails
- */
-export async function parseTemporalAdvanced(query: string): Promise<TemporalParse> {
-  // First try regex patterns
-  const regexResult = parseTemporal(query)
-  if (regexResult.hasTemporal) {
-    return regexResult
-  }
-
-  // Try compromise.js for more complex parsing
-  try {
-    const nlpInstance = await loadNlp()
-    const doc = nlpInstance(query)
-    const dates = doc.dates()
-
-    if (dates.length > 0) {
-      const dateText = dates.text()
-      const parsed = dates.get()[0]
-
-      if (parsed) {
-        const cleanedQuery = query.replace(dateText, '').replace(/\s+/g, ' ').trim()
-
-        return {
-          hasTemporal: true,
-          start: parsed.start ? new Date(parsed.start) : undefined,
-          end: parsed.end ? new Date(parsed.end) : new Date(),
-          expression: dateText,
-          cleanedQuery
-        }
-      }
-    }
-  } catch (error) {
-    // Compromise not available or parsing failed, use regex result
-  }
-
-  return regexResult
-}
-
-/**
- * Format a date range for ChromaDB where clause
- */
-export function formatDateRangeForQuery(
-  temporal: TemporalParse
-): { start?: string; end?: string } | undefined {
-  if (!temporal.hasTemporal) {
-    return undefined
-  }
-
-  return {
-    start: temporal.start?.toISOString(),
-    end: temporal.end?.toISOString()
-  }
-}
-
-export class TemporalParser {
-  parse(query: string): TemporalParse {
-    return parseTemporal(query)
-  }
-
-  async parseAdvanced(query: string): Promise<TemporalParse> {
-    return parseTemporalAdvanced(query)
-  }
-
-  formatForQuery(temporal: TemporalParse) {
-    return formatDateRangeForQuery(temporal)
-  }
-}
+/**
+ * Temporal Parser
+ * Parses temporal expressions in queries using compromise.js
+ */
+
+import type { TemporalParse } from '../types'
+
+// Dynamic import for compromise to avoid bundling issues
+let nlp: unknown
+
+async function loadNlp(): Promise<unknown> {
+  if (!nlp) {
+    nlp = (await import('compromise')).default
+  }
+  return nlp
+}
+
+/** Relative time patterns */
+const RELATIVE_PATTERNS: Array<{
+  pattern: RegExp
+  parse: (match: RegExpMatchArray) => { start?: Date; end?: Date }
+}> = [
+  // "last N days/weeks/months/years"
+  {
+    pattern: /(?:in\s+the\s+)?last\s+(\d+)\s+(day|week|month|year)s?/i,
+    parse: (match) => {
+      const amount = parseInt(match[1]!, 10)
+      const unit = match[2]!.toLowerCase()
+      const now = new Date()
+      const start = new Date(now)
+
+      switch (unit) {
+        case 'day':
+          start.setDate(start.getDate() - amount)
+          break
+        case 'week':
+          start.setDate(start.getDate() - amount * 7)
+          break
+        case 'month':
+          start.setMonth(start.getMonth() - amount)
+          break
+        case 'year':
+          start.setFullYear(start.getFullYear() - amount)
+          break
+      }
+
+      return { start, end: now }
+    }
+  },
+  // "N days/weeks/months ago"
+  {
+    pattern: /(\d+)\s+(day|week|month|year)s?\s+ago/i,
+    parse: (match) => {
+      const amount = parseInt(match[1]!, 10)
+      const unit = match[2]!.toLowerCase()
+      const target = new Date()
+
+      switch (unit) {
+        case 'day':
+          target.setDate(target.getDate() - amount)
+          break
+        case 'week':
+          target.setDate(target.getDate() - amount * 7)
+          break
+        case 'month':
+          target.setMonth(target.getMonth() - amount)
+          break
+        case 'year':
+          target.setFullYear(target.getFullYear() - amount)
+          break
+      }
+
+      // For "X ago", use a range around that date (±1 day)
+      const start = new Date(target)
+      start.setDate(start.getDate() - 1)
+      const end = new Date(target)
+      end.setDate(end.getDate() + 1)
+
+      return { start, end }
+    }
+  },
+  // "this week/month/year"
+  {
+    pattern: /this\s+(week|month|year)/i,
+    parse: (match) => {
+      const unit = match[1]!.toLowerCase()
+      const now = new Date()
+      const start = new Date(now)
+
+      switch (unit) {
+        case 'week':
+          const day = start.getDay()
+          start.setDate(start.getDate() - day) // Start of week (Sunday)
+          break
+        case 'month':
+          start.setDate(1) // Start of month
+          break
+        case 'year':
+          start.setMonth(0, 1) // Start of year
+          break
+      }
+      start.setHours(0, 0, 0, 0)
+
+      return { start, end: now }
+    }
+  },
+  // "yesterday"
+  {
+    pattern: /yesterday/i,
+    parse: () => {
+      const yesterday = new Date()
+      yesterday.setDate(yesterday.getDate() - 1)
+      yesterday.setHours(0, 0, 0, 0)
+
+      const endOfYesterday = new Date(yesterday)
+      endOfYesterday.setHours(23, 59, 59, 999)
+
+      return { start: yesterday, end: endOfYesterday }
+    }
+  },
+  // "today"
+  {
+    pattern: /today/i,
+    parse: () => {
+      const today = new Date()
+      today.setHours(0, 0, 0, 0)
+
+      return { start: today, end: new Date() }
+    }
+  },
+  // "recent" / "recently" / "lately"
+  {
+    pattern: /recent(?:ly)?|lately/i,
+    parse: () => {
+      const now = new Date()
+      const start = new Date(now)
+      start.setDate(start.getDate() - 7) // Default "recent" to 7 days
+
+      return { start, end: now }
+    }
+  },
+  // "past week/month"
+  {
+    pattern: /past\s+(week|month|year)/i,
+    parse: (match) => {
+      const unit = match[1]!.toLowerCase()
+      const now = new Date()
+      const start = new Date(now)
+
+      switch (unit) {
+        case 'week':
+          start.setDate(start.getDate() - 7)
+          break
+        case 'month':
+          start.setMonth(start.getMonth() - 1)
+          break
+        case 'year':
+          start.setFullYear(start.getFullYear() - 1)
+          break
+      }
+
+      return { start, end: now }
+    }
+  },
+  // "since January" / "since 2024"
+  {
+    pattern: /since\s+(january|february|march|april|may|june|july|august|september|october|november|december|\d{4})/i,
+    parse: (match) => {
+      const value = match[1]!.toLowerCase()
+      const start = new Date()
+
+      // Check if it's a year
+      if (/^\d{4}$/.test(value)) {
+        start.setFullYear(parseInt(value, 10), 0, 1)
+      } else {
+        // It's a month
+        const months: Record<string, number> = {
+          january: 0, february: 1, march: 2, april: 3,
+          may: 4, june: 5, july: 6, august: 7,
+          september: 8, october: 9, november: 10, december: 11
+        }
+        const monthIndex = months[value]
+        if (monthIndex !== undefined) {
+          start.setMonth(monthIndex, 1)
+          // If the month is in the future, assume last year
+          if (start > new Date()) {
+            start.setFullYear(start.getFullYear() - 1)
+          }
+        }
+      }
+      start.setHours(0, 0, 0, 0)
+
+      return { start, end: new Date() }
+    }
+  }
+]
+
+/**
+ * Parse temporal expressions from a query
+ */
+export function parseTemporal(query: string): TemporalParse {
+  // Check each pattern
+  for (const { pattern, parse } of RELATIVE_PATTERNS) {
+    const match = query.match(pattern)
+    if (match) {
+      const { start, end } = parse(match)
+
+      // Remove temporal expression from query
+      const cleanedQuery = query.replace(pattern, '').replace(/\s+/g, ' ').trim()
+
+      return {
+        hasTemporal: true,
+        start,
+        end,
+        expression: match[0],
+        cleanedQuery
+      }
+    }
+  }
+
+  return {
+    hasTemporal: false,
+    cleanedQuery: query
+  }
+}
+
+/**
+ * Parse temporal using compromise.js for more complex expressions
+ * Falls back to regex patterns if compromise fails
+ */
+export async function parseTemporalAdvanced(query: string): Promise<TemporalParse> {
+  // First try regex patterns
+  const regexResult = parseTemporal(query)
+  if (regexResult.hasTemporal) {
+    return regexResult
+  }
+
+  // Try compromise.js for more complex parsing
+  try {
+    const nlpInstance = await loadNlp() as (text: string) => { dates(): { length: number; text(): string; get(): Array<{ start?: string; end?: string }> } }
+    const doc = nlpInstance(query)
+    const dates = doc.dates()
+
+    if (dates.length > 0) {
+      const dateText = dates.text()
+      const parsed = dates.get()[0]
+
+      if (parsed) {
+        const cleanedQuery = query.replace(dateText, '').replace(/\s+/g, ' ').trim()
+
+        return {
+          hasTemporal: true,
+          start: parsed.start ? new Date(parsed.start) : undefined,
+          end: parsed.end ? new Date(parsed.end) : new Date(),
+          expression: dateText,
+          cleanedQuery
+        }
+      }
+    }
+  } catch (error) {
+    // Compromise not available or parsing failed, use regex result
+  }
+
+  return regexResult
+}
+
+/**
+ * Format a date range for ChromaDB where clause
+ */
+export function formatDateRangeForQuery(
+  temporal: TemporalParse
+): { start?: string; end?: string } | undefined {
+  if (!temporal.hasTemporal) {
+    return undefined
+  }
+
+  return {
+    start: temporal.start?.toISOString(),
+    end: temporal.end?.toISOString()
+  }
+}
+
+export class TemporalParser {
+  parse(query: string): TemporalParse {
+    return parseTemporal(query)
+  }
+
+  async parseAdvanced(query: string): Promise<TemporalParse> {
+    return parseTemporalAdvanced(query)
+  }
+
+  formatForQuery(temporal: TemporalParse) {
+    return formatDateRangeForQuery(temporal)
+  }
+}