claude-brain 0.17.13 → 0.22.0

package/src/memory/pruning.ts

@@ -0,0 +1,60 @@
+/**
+ * Activity Log Pruning — Phase 30
+ * Removes old activity_log entries to prevent database bloat.
+ * Runs on server startup and can be scheduled for periodic cleanup.
+ */
+
+import type { Database } from 'bun:sqlite'
+import type { Logger } from 'pino'
+
+/**
+ * Prune activity log entries older than maxAgeDays.
+ * Returns the number of rows deleted.
+ */
+export function pruneActivityLog(db: Database, maxAgeDays: number = 30): number {
+  const cutoff = new Date(Date.now() - maxAgeDays * 86400000).toISOString()
+
+  // Count before delete since bun:sqlite db.run doesn't return changes easily
+  const countBefore = (db.prepare('SELECT COUNT(*) as cnt FROM activity_log WHERE created_at < ?').get(cutoff) as any)?.cnt ?? 0
+  if (countBefore === 0) return 0
+
+  db.prepare('DELETE FROM activity_log WHERE created_at < ?').run(cutoff)
+  return countBefore
+}
+
+/**
+ * Start periodic pruning on a timer.
+ * Returns a cleanup function to stop the timer.
+ */
+export function startPeriodicPruning(
+  db: Database,
+  logger: Logger,
+  maxAgeDays: number = 30,
+  intervalMs: number = 24 * 60 * 60 * 1000 // 24 hours
+): () => void {
+  const pruneLogger = logger.child({ component: 'pruning' })
+
+  // Run immediately on startup
+  try {
+    const deleted = pruneActivityLog(db, maxAgeDays)
+    if (deleted > 0) {
+      pruneLogger.info({ deleted, maxAgeDays }, 'Activity log pruned on startup')
+    }
+  } catch (error) {
+    pruneLogger.warn({ error }, 'Failed to prune activity log on startup')
+  }
+
+  // Schedule periodic cleanup
+  const timer = setInterval(() => {
+    try {
+      const deleted = pruneActivityLog(db, maxAgeDays)
+      if (deleted > 0) {
+        pruneLogger.info({ deleted, maxAgeDays }, 'Periodic activity log prune complete')
+      }
+    } catch (error) {
+      pruneLogger.warn({ error }, 'Periodic activity log prune failed')
+    }
+  }, intervalMs)
+
+  return () => clearInterval(timer)
+}

package/src/routing/intent-classifier.ts

@@ -25,6 +25,8 @@ export type Intent =
   | 'list_all'
   | 'update_memory'
   | 'delete_memory'
+  | 'detail_request'
+  | 'timeline'
   | 'no_action'
 
 export interface ClassificationResult {
@@ -201,6 +203,28 @@ const TEMPORAL_PHRASES = [
   'earlier this', 'earlier today', 'over the past'
 ]
 
+// Phase 27: Detail request patterns — "details obs_abc123", "show me obs_abc123"
+const DETAIL_PATTERNS = [
+  /^details?\s+(\S+)/i,           // "details obs_abc123"
+  /^show\s+(?:me\s+)?(\S+)/i,     // "show me obs_abc123" (only when followed by an ID-like string)
+  /^get\s+(?:details?\s+)?(\S+)/i, // "get details obs_abc123"
+  /^expand\s+(\S+)/i,              // "expand obs_abc123"
+  /^more\s+(?:about\s+)?(\S+)/i,   // "more about obs_abc123"
+]
+
+// Phase 27: Timeline patterns
+const TIMELINE_PATTERNS = [
+  /timeline\s+(?:for\s+)?(.+)/i,    // "timeline for expense-tracker"
+  /what\s+did\s+I\s+do\s+(.+)/i,    // "what did I do yesterday"
+  /show\s+(?:me\s+)?history/i,       // "show me history"
+  /recent\s+(?:activity|changes)/i,  // "recent activity"
+]
+
+/** Check if a string looks like an observation ID (contains underscores or 8+ alphanumeric chars) */
+function isIdLike(s: string): boolean {
+  return /[_-]/.test(s) || /^[a-f0-9]{8,}$/i.test(s)
+}
+
 export class IntentClassifier {
   /**
    * Classify the intent of a message
@@ -275,7 +299,18 @@ export class IntentClassifier {
       return { primary: 'session_start', confidence: 0.90, secondary }
     }
 
-    // 12. exploration: timeline, trends, graph, history
+    // 12. detail_request: "details obs_abc123", "show me <id>" (before exploration to avoid misclassification)
+    if (this.isDetailRequest(lower)) {
+      return { primary: 'detail_request', confidence: 0.90, secondary }
+    }
+
+    // 12b. timeline: "timeline for project", "what did I do yesterday", "recent activity" (before exploration)
+    if (this.isTimeline(lower)) {
+      if (hasTemporal) secondary.push('exploration')
+      return { primary: 'timeline', confidence: 0.85, secondary }
+    }
+
+    // 12c. exploration: trends, graph, evolution, history (general exploration that isn't a specific timeline)
     if (this.isExploration(lower)) {
       if (this.isQuestion(lower, message)) secondary.push('question')
       if (hasTemporal) secondary.push('exploration')
@@ -430,6 +465,28 @@ export class IntentClassifier {
     return SESSION_START_PHRASES.some(p => lower.includes(p))
   }
 
+  /**
+   * Phase 27: Detect detail requests — "details <id>", "show me <id>", "expand <id>"
+   * Only matches when the argument looks like an ID (contains underscores, hyphens, or 8+ hex chars).
+   */
+  private isDetailRequest(lower: string): boolean {
+    for (const pattern of DETAIL_PATTERNS) {
+      const match = lower.match(pattern)
+      if (match && match[1] && isIdLike(match[1])) {
+        return true
+      }
+    }
+    return false
+  }
+
+  /**
+   * Phase 27: Detect timeline requests — "timeline for X", "recent activity", "what did I do yesterday"
+   * Distinct from exploration because it specifically asks for chronological activity view.
+   */
+  private isTimeline(lower: string): boolean {
+    return TIMELINE_PATTERNS.some(p => p.test(lower))
+  }
+
   /**
    * Phase 19 B3: Detect temporal signals in the message.
    * Used to add 'temporal' context to secondary intents.

package/src/routing/response-filter.ts

@@ -259,3 +259,131 @@ export class ResponseFilter {
     return `Low relevance match (${score}%)`
   }
 }
+
+// =============================================================================
+// Phase 27: Progressive Disclosure — Compact Response Formatters
+// =============================================================================
+
+/**
+ * Truncate text to maxLen chars, appending "..." if truncated
+ */
+function truncate(text: string, maxLen: number): string {
+  if (!text) return ''
+  if (text.length <= maxLen) return text
+  return text.substring(0, maxLen).trimEnd() + '...'
+}
+
+/**
+ * Format a date as a human-readable relative time string
+ */
+function formatRelativeTime(dateStr: string | Date | undefined): string {
+  if (!dateStr) return 'unknown'
+  const date = typeof dateStr === 'string' ? new Date(dateStr) : dateStr
+  if (isNaN(date.getTime())) return 'unknown'
+  const now = new Date()
+  const diffMs = now.getTime() - date.getTime()
+  const diffMins = Math.floor(diffMs / 60000)
+  const diffHours = Math.floor(diffMs / 3600000)
+  const diffDays = Math.floor(diffMs / 86400000)
+
+  if (diffMins < 1) return 'just now'
+  if (diffMins < 60) return `${diffMins} minute${diffMins === 1 ? '' : 's'} ago`
+  if (diffHours < 24) return `${diffHours} hour${diffHours === 1 ? '' : 's'} ago`
+  if (diffDays === 1) return 'yesterday'
+  if (diffDays < 7) return `${diffDays} days ago`
+  if (diffDays < 30) return `${Math.floor(diffDays / 7)} week${Math.floor(diffDays / 7) === 1 ? '' : 's'} ago`
+  return `${Math.floor(diffDays / 30)} month${Math.floor(diffDays / 30) === 1 ? '' : 's'} ago`
+}
+
+/**
+ * Layer 1: Format a single result as a compact one-liner with metadata
+ */
+export function formatCompactResult(result: any, index: number): string {
+  const meta = result.metadata || {}
+  const category = result.category || result.type || meta.category || result.source || 'memory'
+  const summary = truncate(result.content || result.text || result.decision || '', 80)
+  const project = result.project || meta.project || 'general'
+  const timeAgo = formatRelativeTime(
+    result.createdAt || result.created_at || result.timestamp ||
+    result.date || meta.created_at || meta.createdAt || meta.date
+  )
+  const id = result.id || meta.id || meta.decision_id || 'unknown'
+
+  return `${index}. [${category}] ${summary}\n   Project: ${project} | ${timeAgo}\n   ID: ${id}`
+}
+
+/**
+ * Layer 1: Full compact response with header, compact items, and footer
+ */
+export function formatCompactResponse(results: any[], query: string): string {
+  if (results.length === 0) {
+    return `No memories found for "${query}".`
+  }
+
+  const header = `Found ${results.length} relevant ${results.length === 1 ? 'memory' : 'memories'} for "${query}":`
+  const items = results.map((r, i) => formatCompactResult(r, i + 1)).join('\n\n')
+  const footer = `\nUse brain("details {ID}") for full context.`
+
+  return header + '\n\n' + items + footer
+}
+
+/**
+ * Layer 2: Full detail view for a single observation/memory
+ */
+export function formatDetailResponse(observation: any): string {
+  const category = observation.category || observation.type || 'Memory'
+  const content = observation.content || observation.text || observation.decision || ''
+  const context = observation.context || observation.metadata?.context || ''
+  const reasoning = observation.reasoning || observation.metadata?.reasoning || ''
+  const tags = observation.tags || observation.metadata?.tags || []
+  const created = observation.createdAt || observation.created_at || observation.timestamp || ''
+
+  const lines: string[] = []
+  lines.push(`${category.charAt(0).toUpperCase() + category.slice(1)}: ${content}`)
+  if (context) lines.push(`\nContext: ${context}`)
+  if (reasoning) lines.push(`Reasoning: ${reasoning}`)
+  if (tags.length > 0) lines.push(`Tags: ${Array.isArray(tags) ? tags.join(', ') : tags}`)
+  if (created) lines.push(`Created: ${created}`)
+
+  return lines.join('\n')
+}
+
+/**
+ * Layer 3: Group observations by day for timeline view
+ */
+export function groupByDay(observations: any[]): Map<string, any[]> {
+  const groups = new Map<string, any[]>()
+  for (const obs of observations) {
+    const date = new Date(obs.createdAt || obs.created_at || obs.timestamp || Date.now())
+    const dayKey = isNaN(date.getTime())
+      ? 'Unknown'
+      : date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' })
+    if (!groups.has(dayKey)) groups.set(dayKey, [])
+    groups.get(dayKey)!.push(obs)
+  }
+  return groups
+}
+
+/**
+ * Layer 3: Format a timeline from day-grouped observations
+ */
+export function formatTimeline(grouped: Map<string, any[]>, project?: string): string {
+  if (grouped.size === 0) {
+    return project ? `No activity found for "${project}".` : 'No recent activity found.'
+  }
+
+  const header = project ? `Timeline for ${project}:` : 'Recent timeline:'
+  const sections: string[] = [header, '']
+
+  for (const [day, observations] of grouped) {
+    sections.push(`${day}:`)
+    for (const obs of observations) {
+      const category = obs.category || obs.type || 'memory'
+      const summary = truncate(obs.content || obs.text || obs.decision || '', 60)
+      sections.push(`  - [${category}] ${summary}`)
+    }
+    sections.push('')
+  }
+
+  return sections.join('\n').trim()
+}