claude-brain 0.30.2 → 0.30.3

package/src/intelligence/temporal/query-processor.ts

@@ -1,190 +1,190 @@
-/**
- * Temporal Query Processor
- * Parses temporal expressions from natural language using chrono-node
- */
-
-import * as chrono from 'chrono-node'
-import type { Logger } from 'pino'
-
-export interface TemporalQuery {
-  /** Original query text */
-  original: string
-  /** Cleaned query with temporal expressions removed */
-  cleaned: string
-  /** Parsed start date (if any) */
-  startDate?: string
-  /** Parsed end date (if any) */
-  endDate?: string
-  /** Temporal intent detected */
-  intent: 'range' | 'before' | 'after' | 'point' | 'none'
-  /** Relative time expressions found */
-  expressions: string[]
-}
-
-export class TemporalQueryProcessor {
-  private logger: Logger
-
-  constructor(logger: Logger) {
-    this.logger = logger.child({ component: 'temporal-query-processor' })
-  }
-
-  /**
-   * Parse temporal expressions from a natural language query
-   */
-  parse(query: string): TemporalQuery {
-    const result: TemporalQuery = {
-      original: query,
-      cleaned: query,
-      intent: 'none',
-      expressions: []
-    }
-
-    try {
-      // Parse with chrono-node
-      const parsed = chrono.parse(query, new Date(), { forwardDate: false })
-
-      if (parsed.length === 0) {
-        // Try manual temporal patterns
-        return this.parseManualPatterns(query, result)
-      }
-
-      const ref = parsed[0]!
-      result.expressions.push(ref.text)
-
-      // Remove temporal expression from query for cleaner semantic search
-      result.cleaned = query.replace(ref.text, '').replace(/\s+/g, ' ').trim()
-
-      if (ref.start && ref.end) {
-        // Date range
-        result.startDate = ref.start.date().toISOString()
-        result.endDate = ref.end.date().toISOString()
-        result.intent = 'range'
-      } else if (ref.start) {
-        const startDate = ref.start.date()
-
-        // Check context for before/after
-        const beforeIndex = query.toLowerCase().indexOf('before')
-        const afterIndex = query.toLowerCase().indexOf('after')
-        const sinceIndex = query.toLowerCase().indexOf('since')
-        const untilIndex = query.toLowerCase().indexOf('until')
-
-        if (beforeIndex >= 0 && beforeIndex < query.indexOf(ref.text)) {
-          result.endDate = startDate.toISOString()
-          result.intent = 'before'
-        } else if (
-          (afterIndex >= 0 && afterIndex < query.indexOf(ref.text)) ||
-          (sinceIndex >= 0 && sinceIndex < query.indexOf(ref.text))
-        ) {
-          result.startDate = startDate.toISOString()
-          result.intent = 'after'
-        } else if (untilIndex >= 0 && untilIndex < query.indexOf(ref.text)) {
-          result.endDate = startDate.toISOString()
-          result.intent = 'before'
-        } else {
-          // Default: treat as a point in time, create a window around it
-          const dayBefore = new Date(startDate)
-          dayBefore.setDate(dayBefore.getDate() - 1)
-          const dayAfter = new Date(startDate)
-          dayAfter.setDate(dayAfter.getDate() + 1)
-
-          result.startDate = dayBefore.toISOString()
-          result.endDate = dayAfter.toISOString()
-          result.intent = 'point'
-        }
-      }
-
-      // Handle multiple temporal expressions
-      for (let i = 1; i < parsed.length; i++) {
-        result.expressions.push(parsed[i]!.text)
-        result.cleaned = result.cleaned.replace(parsed[i]!.text, '').replace(/\s+/g, ' ').trim()
-      }
-    } catch (error) {
-      this.logger.debug({ error, query }, 'Failed to parse temporal expression')
-    }
-
-    return result
-  }
-
-  private parseManualPatterns(query: string, result: TemporalQuery): TemporalQuery {
-    const lowerQuery = query.toLowerCase()
-    const now = new Date()
-
-    // "last week", "last month", "last year"
-    const lastMatch = lowerQuery.match(/\b(?:in the )?last\s+(week|month|year|quarter|(\d+)\s*(days?|weeks?|months?))\b/)
-    if (lastMatch) {
-      result.expressions.push(lastMatch[0])
-      result.cleaned = query.replace(new RegExp(lastMatch[0], 'i'), '').replace(/\s+/g, ' ').trim()
-      result.endDate = now.toISOString()
-
-      const start = new Date(now)
-      if (lastMatch[1] === 'week') {
-        start.setDate(start.getDate() - 7)
-      } else if (lastMatch[1] === 'month') {
-        start.setMonth(start.getMonth() - 1)
-      } else if (lastMatch[1] === 'year') {
-        start.setFullYear(start.getFullYear() - 1)
-      } else if (lastMatch[1] === 'quarter') {
-        start.setMonth(start.getMonth() - 3)
-      } else if (lastMatch[2] && lastMatch[3]) {
-        const n = parseInt(lastMatch[2])
-        const unit = lastMatch[3].replace(/s$/, '')
-        if (unit === 'day') start.setDate(start.getDate() - n)
-        else if (unit === 'week') start.setDate(start.getDate() - n * 7)
-        else if (unit === 'month') start.setMonth(start.getMonth() - n)
-      }
-
-      result.startDate = start.toISOString()
-      result.intent = 'range'
-      return result
-    }
-
-    // "recently", "lately"
-    if (/\b(recently|lately)\b/.test(lowerQuery)) {
-      const match = lowerQuery.match(/\b(recently|lately)\b/)!
-      result.expressions.push(match[0])
-      result.cleaned = query.replace(new RegExp(match[0], 'i'), '').replace(/\s+/g, ' ').trim()
-      const start = new Date(now)
-      start.setDate(start.getDate() - 14) // 2 weeks for "recently"
-      result.startDate = start.toISOString()
-      result.endDate = now.toISOString()
-      result.intent = 'range'
-      return result
-    }
-
-    // "this week", "this month", "this year"
-    const thisMatch = lowerQuery.match(/\bthis\s+(week|month|year)\b/)
-    if (thisMatch) {
-      result.expressions.push(thisMatch[0])
-      result.cleaned = query.replace(new RegExp(thisMatch[0], 'i'), '').replace(/\s+/g, ' ').trim()
-      result.endDate = now.toISOString()
-
-      const start = new Date(now)
-      if (thisMatch[1] === 'week') {
-        start.setDate(start.getDate() - start.getDay())
-        start.setHours(0, 0, 0, 0)
-      } else if (thisMatch[1] === 'month') {
-        start.setDate(1)
-        start.setHours(0, 0, 0, 0)
-      } else if (thisMatch[1] === 'year') {
-        start.setMonth(0, 1)
-        start.setHours(0, 0, 0, 0)
-      }
-
-      result.startDate = start.toISOString()
-      result.intent = 'range'
-      return result
-    }
-
-    // "ever", "all time", "historically"
-    if (/\b(ever|all\s+time|historically|over\s+time)\b/.test(lowerQuery)) {
-      const match = lowerQuery.match(/\b(ever|all\s+time|historically|over\s+time)\b/)!
-      result.expressions.push(match[0])
-      result.cleaned = query.replace(new RegExp(match[0], 'i'), '').replace(/\s+/g, ' ').trim()
-      result.intent = 'range'
-      // No date constraints = all time
-      return result
-    }
-
-    return result
-  }
-}
+/**
+ * Temporal Query Processor
+ * Parses temporal expressions from natural language using chrono-node
+ */
+
+import * as chrono from 'chrono-node'
+import type { Logger } from 'pino'
+
+export interface TemporalQuery {
+  /** Original query text */
+  original: string
+  /** Cleaned query with temporal expressions removed */
+  cleaned: string
+  /** Parsed start date (if any) */
+  startDate?: string
+  /** Parsed end date (if any) */
+  endDate?: string
+  /** Temporal intent detected */
+  intent: 'range' | 'before' | 'after' | 'point' | 'none'
+  /** Relative time expressions found */
+  expressions: string[]
+}
+
+export class TemporalQueryProcessor {
+  private logger: Logger
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'temporal-query-processor' })
+  }
+
+  /**
+   * Parse temporal expressions from a natural language query
+   */
+  parse(query: string): TemporalQuery {
+    const result: TemporalQuery = {
+      original: query,
+      cleaned: query,
+      intent: 'none',
+      expressions: []
+    }
+
+    try {
+      // Parse with chrono-node
+      const parsed = chrono.parse(query, new Date(), { forwardDate: false })
+
+      if (parsed.length === 0) {
+        // Try manual temporal patterns
+        return this.parseManualPatterns(query, result)
+      }
+
+      const ref = parsed[0]!
+      result.expressions.push(ref.text)
+
+      // Remove temporal expression from query for cleaner semantic search
+      result.cleaned = query.replace(ref.text, '').replace(/\s+/g, ' ').trim()
+
+      if (ref.start && ref.end) {
+        // Date range
+        result.startDate = ref.start.date().toISOString()
+        result.endDate = ref.end.date().toISOString()
+        result.intent = 'range'
+      } else if (ref.start) {
+        const startDate = ref.start.date()
+
+        // Check context for before/after
+        const beforeIndex = query.toLowerCase().indexOf('before')
+        const afterIndex = query.toLowerCase().indexOf('after')
+        const sinceIndex = query.toLowerCase().indexOf('since')
+        const untilIndex = query.toLowerCase().indexOf('until')
+
+        if (beforeIndex >= 0 && beforeIndex < query.indexOf(ref.text)) {
+          result.endDate = startDate.toISOString()
+          result.intent = 'before'
+        } else if (
+          (afterIndex >= 0 && afterIndex < query.indexOf(ref.text)) ||
+          (sinceIndex >= 0 && sinceIndex < query.indexOf(ref.text))
+        ) {
+          result.startDate = startDate.toISOString()
+          result.intent = 'after'
+        } else if (untilIndex >= 0 && untilIndex < query.indexOf(ref.text)) {
+          result.endDate = startDate.toISOString()
+          result.intent = 'before'
+        } else {
+          // Default: treat as a point in time, create a window around it
+          const dayBefore = new Date(startDate)
+          dayBefore.setDate(dayBefore.getDate() - 1)
+          const dayAfter = new Date(startDate)
+          dayAfter.setDate(dayAfter.getDate() + 1)
+
+          result.startDate = dayBefore.toISOString()
+          result.endDate = dayAfter.toISOString()
+          result.intent = 'point'
+        }
+      }
+
+      // Handle multiple temporal expressions
+      for (let i = 1; i < parsed.length; i++) {
+        result.expressions.push(parsed[i]!.text)
+        result.cleaned = result.cleaned.replace(parsed[i]!.text, '').replace(/\s+/g, ' ').trim()
+      }
+    } catch (error) {
+      this.logger.debug({ error, query }, 'Failed to parse temporal expression')
+    }
+
+    return result
+  }
+
+  private parseManualPatterns(query: string, result: TemporalQuery): TemporalQuery {
+    const lowerQuery = query.toLowerCase()
+    const now = new Date()
+
+    // "last week", "last month", "last year"
+    const lastMatch = lowerQuery.match(/\b(?:in the )?last\s+(week|month|year|quarter|(\d+)\s*(days?|weeks?|months?))\b/)
+    if (lastMatch) {
+      result.expressions.push(lastMatch[0])
+      result.cleaned = query.replace(new RegExp(lastMatch[0], 'i'), '').replace(/\s+/g, ' ').trim()
+      result.endDate = now.toISOString()
+
+      const start = new Date(now)
+      if (lastMatch[1] === 'week') {
+        start.setDate(start.getDate() - 7)
+      } else if (lastMatch[1] === 'month') {
+        start.setMonth(start.getMonth() - 1)
+      } else if (lastMatch[1] === 'year') {
+        start.setFullYear(start.getFullYear() - 1)
+      } else if (lastMatch[1] === 'quarter') {
+        start.setMonth(start.getMonth() - 3)
+      } else if (lastMatch[2] && lastMatch[3]) {
+        const n = parseInt(lastMatch[2])
+        const unit = lastMatch[3].replace(/s$/, '')
+        if (unit === 'day') start.setDate(start.getDate() - n)
+        else if (unit === 'week') start.setDate(start.getDate() - n * 7)
+        else if (unit === 'month') start.setMonth(start.getMonth() - n)
+      }
+
+      result.startDate = start.toISOString()
+      result.intent = 'range'
+      return result
+    }
+
+    // "recently", "lately"
+    if (/\b(recently|lately)\b/.test(lowerQuery)) {
+      const match = lowerQuery.match(/\b(recently|lately)\b/)!
+      result.expressions.push(match[0])
+      result.cleaned = query.replace(new RegExp(match[0], 'i'), '').replace(/\s+/g, ' ').trim()
+      const start = new Date(now)
+      start.setDate(start.getDate() - 14) // 2 weeks for "recently"
+      result.startDate = start.toISOString()
+      result.endDate = now.toISOString()
+      result.intent = 'range'
+      return result
+    }
+
+    // "this week", "this month", "this year"
+    const thisMatch = lowerQuery.match(/\bthis\s+(week|month|year)\b/)
+    if (thisMatch) {
+      result.expressions.push(thisMatch[0])
+      result.cleaned = query.replace(new RegExp(thisMatch[0], 'i'), '').replace(/\s+/g, ' ').trim()
+      result.endDate = now.toISOString()
+
+      const start = new Date(now)
+      if (thisMatch[1] === 'week') {
+        start.setDate(start.getDate() - start.getDay())
+        start.setHours(0, 0, 0, 0)
+      } else if (thisMatch[1] === 'month') {
+        start.setDate(1)
+        start.setHours(0, 0, 0, 0)
+      } else if (thisMatch[1] === 'year') {
+        start.setMonth(0, 1)
+        start.setHours(0, 0, 0, 0)
+      }
+
+      result.startDate = start.toISOString()
+      result.intent = 'range'
+      return result
+    }
+
+    // "ever", "all time", "historically"
+    if (/\b(ever|all\s+time|historically|over\s+time)\b/.test(lowerQuery)) {
+      const match = lowerQuery.match(/\b(ever|all\s+time|historically|over\s+time)\b/)!
+      result.expressions.push(match[0])
+      result.cleaned = query.replace(new RegExp(match[0], 'i'), '').replace(/\s+/g, ' ').trim()
+      result.intent = 'range'
+      // No date constraints = all time
+      return result
+    }
+
+    return result
+  }
+}