@onmars/lunar-core 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onmars/lunar-core",
-  "version": "0.5.0",
+  "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'
@@ -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],
 ])
 
 /**