@onmars/lunar-core 0.4.7 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onmars/lunar-core",
-  "version": "0.4.7",
+  "version": "0.6.0",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/lib/hook-runner.ts

@@ -19,6 +19,9 @@
  *   minMessages        — Minimum session message count
  */
 
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { execSync } from 'node:child_process'
 import type { Fact, MemoryProvider, MemoryResult } from '../types/memory'
 import type { HookCondition, HookEntry, HooksConfig, LifecycleEvent } from './config-loader'
 import { log } from './logger'
@@ -42,7 +45,7 @@ export interface HookContext {
   /** Current session message count */
   messageCount: number
   /** Session messages (for summarize, promote) */
-  messages?: Array<{ role: string; content: string }>
+  messages?: Array<{ role: string; content: string; timestamp?: string }>
   /** Recall results — mutable (afterRecall boost modifies scores) */
   results?: MemoryResult[]
   /** Search query — mutable (beforeRecall can expand/modify) */
@@ -1129,6 +1132,206 @@ const executeDiaryRecall: ActionExecutor = async (hook, context, providers) => {
   }
 }
 
+// ════════════════════════════════════════════════════════════
+// sessionLog — Write session summary to memory/YYYY-MM-DD.md
+// ════════════════════════════════════════════════════════════
+
+/**
+ * `sessionLog` — Write session details to a daily markdown file.
+ *
+ * Creates/appends to `~/.lunar/memory/YYYY-MM-DD.md` with session summary,
+ * topics, channel, and message count. This serves as an offline backup
+ * that's git-tracked and grep-searchable, independent of Brain availability.
+ *
+ * Fields: (none required — uses context)
+ * Events: afterSessionEnd
+ */
+const executeSessionLog: ActionExecutor = async (_hook, context) => {
+  if (!context.sessionSummary && (!context.messages || context.messages.length === 0)) {
+    log.debug({ action: 'sessionLog' }, 'Hook sessionLog: no summary or messages — skipping')
+    return
+  }
+
+  const sessionDate = context.sessionDate ?? new Date().toISOString().split('T')[0]
+  const memoryDir = join(process.env.HOME ?? '/home/mars', '.lunar', 'memory')
+  const filePath = join(memoryDir, `${sessionDate}.md`)
+
+  try {
+    // Ensure memory directory exists
+    if (!existsSync(memoryDir)) {
+      mkdirSync(memoryDir, { recursive: true })
+    }
+
+    const now = new Date()
+    const timeStr = now.toLocaleTimeString('es-ES', { hour: '2-digit', minute: '2-digit' })
+    const channel = context.channel ?? 'unknown'
+
+    // Build session section
+    const lines: string[] = []
+
+    // Add header if file is new
+    if (!existsSync(filePath)) {
+      lines.push(`# Session Log — ${sessionDate}`)
+      lines.push('')
+    }
+
+    lines.push(`## ${timeStr} — #${channel} (${context.messageCount} msgs)`)
+    lines.push('')
+
+    if (context.topics?.length) {
+      lines.push(`**Topics:** ${context.topics.join(', ')}`)
+      lines.push('')
+    }
+
+    if (context.sessionSummary) {
+      lines.push('### Summary')
+      lines.push('')
+      lines.push(context.sessionSummary)
+      lines.push('')
+    }
+
+    if (context.episodeId) {
+      lines.push(`*Episode: ${context.episodeId.slice(0, 8)}*`)
+      lines.push('')
+    }
+
+    lines.push('---')
+    lines.push('')
+
+    const content = lines.join('\n')
+
+    // Append to existing file or create new
+    if (existsSync(filePath)) {
+      appendFileSync(filePath, content, 'utf-8')
+    } else {
+      writeFileSync(filePath, content, 'utf-8')
+    }
+
+    log.info(
+      { file: filePath, channel, messageCount: context.messageCount },
+      'Hook sessionLog: written',
+    )
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err)
+    log.warn({ error: errMsg, file: filePath }, 'Hook sessionLog: failed — continuing')
+  }
+}
+
+// ════════════════════════════════════════════════════════════
+// pipelineExtract — Extract entities/facts via Brain pipeline
+// ════════════════════════════════════════════════════════════
+
+/**
+ * `pipelineExtract` — Call Brain's pipeline/extract endpoint to automatically
+ * extract entities, facts, and relations from the conversation transcript.
+ *
+ * Fields: provider (brain provider with extractPipeline support)
+ * Events: afterSessionEnd
+ */
+const executePipelineExtract: ActionExecutor = async (hook, context, providers) => {
+  const { provider: providerName } = hook
+
+  if (!providerName) {
+    log.warn({ action: 'pipelineExtract' }, 'Hook pipelineExtract: requires "provider" — skipping')
+    return
+  }
+
+  if (!context.messages || context.messages.length < 4) {
+    log.debug(
+      { action: 'pipelineExtract', messageCount: context.messages?.length ?? 0 },
+      'Hook pipelineExtract: too few messages — skipping',
+    )
+    return
+  }
+
+  const provider = providers.get(providerName)
+  if (!provider) {
+    log.warn(
+      { provider: providerName, action: 'pipelineExtract' },
+      'Hook pipelineExtract: provider not found — skipping',
+    )
+    return
+  }
+
+  // Access brain-specific extractPipeline method
+  const brain = provider as unknown as {
+    extractPipeline?: (conversation: string, channel?: string, sessionDate?: string) => Promise<unknown>
+  }
+  if (!brain.extractPipeline) {
+    log.warn(
+      { action: 'pipelineExtract' },
+      'Hook pipelineExtract: provider does not support extractPipeline — skipping',
+    )
+    return
+  }
+
+  try {
+    const transcript = smartTruncate(
+      context.messages.map((m) => `${m.role}: ${m.content}`).join('\n'),
+      MAX_TRANSCRIPT_CHARS,
+    )
+
+    const sessionDate = context.sessionDate ?? new Date().toISOString().split('T')[0]
+
+    await brain.extractPipeline(transcript, context.channel ?? 'unknown', sessionDate)
+
+    log.info(
+      { provider: providerName, chars: transcript.length },
+      'Hook pipelineExtract: complete',
+    )
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err)
+    log.warn({ error: errMsg }, 'Hook pipelineExtract: failed — continuing')
+  }
+}
+
+// ════════════════════════════════════════════════════════════
+// gitSync — Commit and push workspace changes
+// ════════════════════════════════════════════════════════════
+
+/**
+ * `gitSync` — Commit and push any workspace changes after session end.
+ *
+ * Runs: git add -A && git commit && git push in the workspace directory.
+ * Best-effort: failures are logged but never block the flow.
+ *
+ * Fields: (none — uses ~/.lunar as workspace)
+ * Events: afterSessionEnd (should be LAST hook)
+ */
+const executeGitSync: ActionExecutor = async () => {
+  const workspaceDir = join(process.env.HOME ?? '/home/mars', '.lunar')
+
+  try {
+    // Check if there are changes to commit
+    const status = execSync('git status --porcelain', {
+      cwd: workspaceDir,
+      encoding: 'utf-8',
+      timeout: 10_000,
+    }).trim()
+
+    if (!status) {
+      log.debug({ action: 'gitSync' }, 'Hook gitSync: no changes — skipping')
+      return
+    }
+
+    const today = new Date().toISOString().split('T')[0]
+    const commitMsg = `session log ${today} — auto-sync`
+
+    execSync('git add -A', { cwd: workspaceDir, timeout: 10_000 })
+    execSync(`git commit -m "${commitMsg}"`, {
+      cwd: workspaceDir,
+      timeout: 15_000,
+    })
+    execSync('git push', { cwd: workspaceDir, timeout: 30_000 })
+
+    log.info({ workspace: workspaceDir }, 'Hook gitSync: committed and pushed')
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err)
+    // Git sync failure is non-critical — don't block
+    log.warn({ error: errMsg }, 'Hook gitSync: failed — continuing')
+  }
+}
+
 const ACTION_REGISTRY = new Map<string, ActionExecutor>([
   ['promote', executePromote],
   ['boost', executeBoost],
@@ -1140,6 +1343,9 @@ const ACTION_REGISTRY = new Map<string, ActionExecutor>([
   ['reconcile', executeReconcile],
   ['episodeClose', executeEpisodeClose],
   ['diaryRecall', executeDiaryRecall],
+  ['sessionLog', executeSessionLog],
+  ['pipelineExtract', executePipelineExtract],
+  ['gitSync', executeGitSync],
 ])
 
 /**

package/src/lib/memory-orchestrator.ts

@@ -151,6 +151,55 @@ export class MemoryOrchestrator implements MemoryProvider {
     return this.diaryResults.length
   }
 
+  /**
+   * Refresh episode for a new session (called after /clear).
+   * Creates a new episode with today's date, replacing the stale one.
+   */
+  async refreshEpisode(channel?: string): Promise<void> {
+    if (!this.hookRunner?.hasHooks('sessionStart')) return
+
+    const context: HookContext = {
+      messageCount: 0,
+      channel,
+      sessionDate: new Date().toISOString().split('T')[0],
+    }
+    const result = await this.hookRunner.run('sessionStart', context)
+    if (result.episodeId) {
+      this.currentEpisodeId = result.episodeId
+      this.currentSessionDate = result.sessionDate
+      log.info(
+        { episodeId: result.episodeId, sessionDate: result.sessionDate },
+        'Episode refreshed after clear',
+      )
+    }
+    if (result.results?.length) {
+      this.diaryResults = result.results
+    }
+  }
+
+  /**
+   * Get or create an episode for a specific date (used by day-split in /clear).
+   * Does NOT change the current orchestrator state.
+   */
+  async getEpisodeForDate(date: string, channel?: string): Promise<string | undefined> {
+    // Find a provider that supports getOrCreateEpisode (Brain provider)
+    const brain = [...this.providersByName.values()].find(
+      (p) => (p as any).getOrCreateEpisode !== undefined,
+    ) as any
+    if (!brain?.getOrCreateEpisode) return undefined
+
+    try {
+      const episode = await brain.getOrCreateEpisode(date, channel)
+      return episode.id
+    } catch (err) {
+      log.warn(
+        { error: err instanceof Error ? err.message : String(err), date },
+        'Failed to get episode for date',
+      )
+      return undefined
+    }
+  }
+
   /**
    * Destroy all providers.
    */
@@ -291,7 +340,7 @@ export class MemoryOrchestrator implements MemoryProvider {
    *   3. afterSessionEnd hooks (promote → Engram facts → Brain)
    */
   async onSessionEnd(context: {
-    messages: Array<{ role: string; content: string }>
+    messages: Array<{ role: string; content: string; timestamp?: string }>
     sessionSummary?: string
     topics?: string[]
     episodeId?: string

package/src/lib/router.ts

@@ -60,7 +60,7 @@ export class Router {
    * In-memory message history per session — used for graceful session close.
    * Capped at MAX_SESSION_HISTORY messages per session to bound memory usage.
    */
-  private sessionMessages = new Map<string, Array<{ role: string; content: string }>>()
+  private sessionMessages = new Map<string, Array<{ role: string; content: string; timestamp?: string }>>()
   private static readonly MAX_SESSION_HISTORY = 200
 
   /** Tracks cumulative token usage per session */
@@ -582,18 +582,53 @@ export class Router {
       if (messages.length > 0) {
         try {
           const orchestrator = this.memory as unknown as MemoryOrchestrator
-          const clearContext: Record<string, unknown> = {
-            messages,
-            topics: this.extractTopics(messages),
+
+          // Group messages by day (using timestamp if available, else today)
+          const today = new Date().toISOString().split('T')[0]
+          const messagesByDay = new Map<string, typeof messages>()
+
+          for (const msg of messages) {
+            const day = msg.timestamp ? msg.timestamp.split('T')[0] : today
+            if (!messagesByDay.has(day)) messagesByDay.set(day, [])
+            messagesByDay.get(day)!.push(msg)
+          }
+
+          // Sort days chronologically
+          const sortedDays = [...messagesByDay.keys()].sort()
+
+          // Extract channel from sessionKey (format: agentId:platform:channelId)
+          const channel = sessionKey.split(':').slice(1).join(':')
+
+          // Run hooks for each day's messages
+          for (const day of sortedDays) {
+            const dayMessages = messagesByDay.get(day)!
+            const clearContext: Record<string, unknown> = {
+              messages: dayMessages,
+              topics: this.extractTopics(dayMessages),
+              sessionDate: day,
+            }
+
+            // Get or create episode for this specific day
+            if (orchestrator?.getEpisodeForDate) {
+              const episodeId = await orchestrator.getEpisodeForDate(day, channel)
+              if (episodeId) clearContext.episodeId = episodeId
+            }
+
+            await this.memory!.onSessionEnd(
+              clearContext as Parameters<NonNullable<MemoryProvider['onSessionEnd']>>[0],
+            )
           }
-          if (orchestrator?.episodeId) clearContext.episodeId = orchestrator.episodeId
-          if (orchestrator?.sessionDate) clearContext.sessionDate = orchestrator.sessionDate
 
-          await this.memory.onSessionEnd(
-            clearContext as Parameters<NonNullable<MemoryProvider['onSessionEnd']>>[0],
-          )
           hooksRan = true
-          log.info({ sessionKey, messageCount: messages.length }, 'Memory hooks ran before clear')
+          log.info(
+            { sessionKey, messageCount: messages.length, days: sortedDays.length },
+            'Memory hooks ran before clear',
+          )
+
+          // Refresh episode for next session
+          if (orchestrator?.refreshEpisode) {
+            await orchestrator.refreshEpisode(channel)
+          }
         } catch (err) {
           const errMsg = err instanceof Error ? err.message : String(err)
           log.warn({ sessionKey, error: errMsg }, 'Memory hooks failed during /clear')
@@ -794,19 +829,48 @@ export class Router {
       closePromises.push(
         (async () => {
           try {
-            // Pass episodeId from orchestrator if available
             const orchestrator = this.memory as unknown as MemoryOrchestrator
-            const sessionContext: Record<string, unknown> = {
-              messages,
-              topics: this.extractTopics(messages),
+
+            // Group messages by day (using timestamp if available, else today)
+            const today = new Date().toISOString().split('T')[0]
+            const messagesByDay = new Map<string, typeof messages>()
+
+            for (const msg of messages) {
+              const day = msg.timestamp ? msg.timestamp.split('T')[0] : today
+              if (!messagesByDay.has(day)) messagesByDay.set(day, [])
+              messagesByDay.get(day)!.push(msg)
+            }
+
+            // Sort days chronologically
+            const sortedDays = [...messagesByDay.keys()].sort()
+
+            // Extract channel from sessionKey (format: agentId:platform:channelId)
+            const channel = sessionKey.split(':').slice(1).join(':')
+
+            // Run hooks for each day's messages
+            for (const day of sortedDays) {
+              const dayMessages = messagesByDay.get(day)!
+              const sessionContext: Record<string, unknown> = {
+                messages: dayMessages,
+                topics: this.extractTopics(dayMessages),
+                sessionDate: day,
+              }
+
+              // Get or create episode for this specific day
+              if (orchestrator?.getEpisodeForDate) {
+                const episodeId = await orchestrator.getEpisodeForDate(day, channel)
+                if (episodeId) sessionContext.episodeId = episodeId
+              }
+
+              await this.memory!.onSessionEnd!(
+                sessionContext as Parameters<NonNullable<MemoryProvider['onSessionEnd']>>[0],
+              )
             }
-            if (orchestrator?.episodeId) sessionContext.episodeId = orchestrator.episodeId
-            if (orchestrator?.sessionDate) sessionContext.sessionDate = orchestrator.sessionDate
 
-            await this.memory!.onSessionEnd!(
-              sessionContext as Parameters<NonNullable<MemoryProvider['onSessionEnd']>>[0],
+            log.info(
+              { sessionKey, messageCount: messages.length, days: sortedDays.length },
+              'Session closed gracefully',
             )
-            log.info({ sessionKey, messageCount: messages.length }, 'Session closed gracefully')
           } catch (err) {
             const errMsg = err instanceof Error ? err.message : String(err)
             log.warn(
@@ -849,7 +913,7 @@ export class Router {
       this.sessionMessages.set(sessionKey, history)
     }
 
-    history.push({ role, content })
+    history.push({ role, content, timestamp: new Date().toISOString() })
 
     // Cap to prevent unbounded memory growth
     if (history.length > Router.MAX_SESSION_HISTORY) {

package/src/types/memory.ts

@@ -78,7 +78,7 @@ export interface MemoryProvider {
    *   - Markdown: write daily note
    */
   onSessionEnd?(context: {
-    messages: Array<{ role: string; content: string }>
+    messages: Array<{ role: string; content: string; timestamp?: string }>
     sessionSummary?: string
     topics?: string[]
   }): Promise<void>