@geekbeer/minion 2.46.1 → 2.48.1

package/core/config.js

@@ -12,6 +12,8 @@
  * Other optional environment variables:
  * - AGENT_PORT: Port for the local agent server (default: 8080)
  * - MINION_USER: System user running the agent (used to resolve home directory)
+ * - REFLECTION_TIME: Daily self-reflection time in HH:MM format (e.g., "03:00")
+ * - TIMEZONE: Timezone for reflection schedule (default: "Asia/Tokyo")
  */
 
 const os = require('os')
@@ -87,6 +89,11 @@ const config = {
   //   LLM_COMMAND="claude -p '{prompt}'"
   //   LLM_COMMAND="gemini-cli --prompt '{prompt}'"
   LLM_COMMAND: process.env.LLM_COMMAND || '',
+
+  // Self-reflection schedule (自己反省時間)
+  // Daily time to automatically run end-of-day processing (log + memory extraction + session clear)
+  REFLECTION_TIME: process.env.REFLECTION_TIME ?? '03:00',  // "HH:MM" format, empty = disabled
+  TIMEZONE: process.env.TIMEZONE || 'Asia/Tokyo',
 }
 
 /**

package/core/lib/end-of-day.js

@@ -0,0 +1,113 @@
+/**
+ * Shared end-of-day processing logic
+ *
+ * Extracts daily conversation summary and long-term learnings from the chat session.
+ * Used by both the chat route (manual trigger) and the reflection scheduler (automatic).
+ *
+ * @module core/lib/end-of-day
+ */
+
+const chatStore = require('../stores/chat-store')
+const memoryStore = require('../stores/memory-store')
+const dailyLogStore = require('../stores/daily-log-store')
+
+/**
+ * Run end-of-day processing: generate daily log + extract memories from conversation.
+ *
+ * @param {Object} opts
+ * @param {(prompt: string) => Promise<string>} opts.runQuickLlmCall - Platform-specific LLM call function
+ * @param {boolean} [opts.clearSession=false] - Whether to clear the chat session after processing
+ * @returns {Promise<{ daily_log: string|null, memory_entries_added: number }>}
+ */
+async function runEndOfDay({ runQuickLlmCall, clearSession = false }) {
+  const session = await chatStore.load()
+  if (!session || session.messages.length === 0) {
+    return { daily_log: null, memory_entries_added: 0 }
+  }
+
+  // Build conversation text for summarization (last 50 messages)
+  const messages = session.messages.slice(-50)
+  const conversationText = messages
+    .map(m => `${m.role === 'user' ? 'ユーザー' : 'アシスタント'}: ${m.content.substring(0, 500)}`)
+    .join('\n\n')
+
+  const endOfDayPrompt = `以下の会話を分析して、JSON形式で2つの情報を出力してください。
+
+1. daily_summary: 今日の会話の要約（マークダウン形式）。以下を含めてください：
+   - 今日やったこと・話したこと
+   - 未解決の課題・明日への申し送り
+   - 重要な決定事項
+
+2. learnings: 長期的に記憶すべき学び（配列）。各要素は以下の形式：
+   - title: 短いタイトル
+   - category: user（ユーザーの好み）/ feedback（フィードバック）/ project（プロジェクト情報）/ reference（参照情報）のいずれか
+   - content: 詳細な内容
+
+学びがない場合は空配列にしてください。すでに常識的なことは含めないでください。
+
+会話:
+${conversationText}
+
+JSON形式のみで回答してください（\`\`\`jsonブロックは不要）:`
+
+  const today = new Date().toISOString().split('T')[0]
+  let dailyLog = null
+  let memoriesAdded = 0
+
+  try {
+    const result = await runQuickLlmCall(endOfDayPrompt)
+
+    // Parse JSON response
+    let parsed
+    try {
+      // Try to extract JSON from the response (may be wrapped in markdown code blocks)
+      const jsonMatch = result.match(/\{[\s\S]*\}/)
+      parsed = jsonMatch ? JSON.parse(jsonMatch[0]) : JSON.parse(result)
+    } catch {
+      // Fallback: use raw result as daily summary
+      parsed = { daily_summary: result, learnings: [] }
+    }
+
+    // Save daily log
+    if (parsed.daily_summary) {
+      dailyLog = parsed.daily_summary
+      await dailyLogStore.saveLog(today, dailyLog)
+      console.log(`[EndOfDay] Saved daily log for ${today}`)
+    }
+
+    // Save learnings to memory
+    if (Array.isArray(parsed.learnings)) {
+      for (const learning of parsed.learnings) {
+        if (learning.title && learning.content) {
+          await memoryStore.saveEntry({
+            title: learning.title,
+            category: learning.category || 'reference',
+            content: learning.content,
+          })
+          memoriesAdded++
+        }
+      }
+      if (memoriesAdded > 0) {
+        console.log(`[EndOfDay] Saved ${memoriesAdded} memory entries`)
+      }
+    }
+  } catch (err) {
+    console.error('[EndOfDay] Summarization failed:', err.message)
+
+    // Fallback: save raw conversation summary as daily log
+    const fallback = messages.slice(-8)
+      .map(m => `**${m.role === 'user' ? 'ユーザー' : 'アシスタント'}**: ${m.content.substring(0, 300)}`)
+      .join('\n\n')
+    dailyLog = `# ${today} 会話ログ\n\n${fallback}`
+    await dailyLogStore.saveLog(today, dailyLog)
+  }
+
+  if (clearSession) {
+    await chatStore.clear()
+    console.log('[EndOfDay] Session cleared')
+  }
+
+  return { daily_log: today, memory_entries_added: memoriesAdded }
+}
+
+module.exports = { runEndOfDay }

package/core/lib/reflection-scheduler.js

@@ -0,0 +1,157 @@
+/**
+ * Reflection Scheduler (自己反省スケジューラ)
+ *
+ * Built-in server-level scheduler that triggers end-of-day processing
+ * (daily log generation + memory extraction + session clear) at a configured time.
+ *
+ * Unlike routines (user-deletable), this is a core architectural feature
+ * that ensures the minion regularly consolidates its conversation history.
+ *
+ * Configuration:
+ *   REFLECTION_TIME - Time to run daily reflection (format: "HH:MM", e.g., "03:00")
+ *   TIMEZONE        - Timezone for the schedule (default: "Asia/Tokyo")
+ *
+ * @module core/lib/reflection-scheduler
+ */
+
+const { Cron } = require('croner')
+const { config } = require('../config')
+const { runEndOfDay } = require('./end-of-day')
+
+/** @type {import('croner').Cron | null} */
+let cronJob = null
+
+/** @type {boolean} */
+let isRunning = false
+
+/** @type {((prompt: string) => Promise<string>) | null} */
+let llmCallFn = null
+
+/**
+ * Parse "HH:MM" into a cron expression "0 MM HH * * *"
+ * @param {string} timeStr - Time in "HH:MM" format
+ * @returns {string|null} Cron expression or null if invalid
+ */
+function parseToCron(timeStr) {
+  if (!timeStr || typeof timeStr !== 'string') return null
+  const match = timeStr.match(/^(\d{1,2}):(\d{2})$/)
+  if (!match) return null
+  const hour = parseInt(match[1], 10)
+  const minute = parseInt(match[2], 10)
+  if (hour < 0 || hour > 23 || minute < 0 || minute > 59) return null
+  return `0 ${minute} ${hour} * * *`
+}
+
+/**
+ * Start the reflection scheduler.
+ * If REFLECTION_TIME is not configured, the scheduler remains inactive.
+ *
+ * @param {(prompt: string) => Promise<string>} runQuickLlmCall - Platform-specific LLM call function
+ */
+function start(runQuickLlmCall) {
+  llmCallFn = runQuickLlmCall
+
+  const reflectionTime = config.REFLECTION_TIME
+  if (!reflectionTime) {
+    console.log('[ReflectionScheduler] REFLECTION_TIME not configured, scheduler inactive')
+    return
+  }
+
+  const cronExpr = parseToCron(reflectionTime)
+  if (!cronExpr) {
+    console.error(`[ReflectionScheduler] Invalid REFLECTION_TIME: "${reflectionTime}" (expected HH:MM)`)
+    return
+  }
+
+  const timezone = config.TIMEZONE || 'Asia/Tokyo'
+
+  try {
+    cronJob = new Cron(cronExpr, { timezone }, async () => {
+      await runReflection()
+    })
+
+    const nextRun = cronJob.nextRun()
+    console.log(`[ReflectionScheduler] Scheduled at ${reflectionTime} (${timezone}), next run: ${nextRun ? nextRun.toISOString() : 'unknown'}`)
+  } catch (err) {
+    console.error(`[ReflectionScheduler] Failed to start: ${err.message}`)
+  }
+}
+
+/**
+ * Stop the reflection scheduler.
+ */
+function stop() {
+  if (cronJob) {
+    cronJob.stop()
+    cronJob = null
+    console.log('[ReflectionScheduler] Stopped')
+  }
+}
+
+/**
+ * Reschedule after config change (e.g., REFLECTION_TIME or TIMEZONE updated via API).
+ * Requires that start() was called previously with a runQuickLlmCall function.
+ */
+function reschedule() {
+  if (!llmCallFn) {
+    console.warn('[ReflectionScheduler] Cannot reschedule: no LLM call function registered')
+    return
+  }
+  stop()
+  start(llmCallFn)
+}
+
+/**
+ * Execute the reflection (end-of-day processing).
+ * Guards against concurrent execution.
+ */
+async function runReflection() {
+  if (isRunning) {
+    console.log('[ReflectionScheduler] Already running, skipping')
+    return
+  }
+
+  if (!llmCallFn) {
+    console.error('[ReflectionScheduler] No LLM call function registered')
+    return
+  }
+
+  isRunning = true
+  console.log('[ReflectionScheduler] Starting daily reflection...')
+
+  try {
+    const result = await runEndOfDay({
+      runQuickLlmCall: llmCallFn,
+      clearSession: true,
+    })
+
+    if (result.daily_log) {
+      console.log(`[ReflectionScheduler] Completed: log=${result.daily_log}, memories=${result.memory_entries_added}`)
+    } else {
+      console.log('[ReflectionScheduler] Completed: no conversation to process')
+    }
+  } catch (err) {
+    console.error(`[ReflectionScheduler] Failed: ${err.message}`)
+  } finally {
+    isRunning = false
+  }
+}
+
+/**
+ * Get the current scheduler status.
+ * @returns {{ enabled: boolean, reflection_time: string, timezone: string, next_run: string|null }}
+ */
+function getStatus() {
+  const reflectionTime = config.REFLECTION_TIME || ''
+  const timezone = config.TIMEZONE || 'Asia/Tokyo'
+  const nextRun = cronJob ? cronJob.nextRun() : null
+
+  return {
+    enabled: !!cronJob,
+    reflection_time: reflectionTime,
+    timezone,
+    next_run: nextRun ? nextRun.toISOString() : null,
+  }
+}
+
+module.exports = { start, stop, reschedule, getStatus }

package/core/routes/daily-logs.js

@@ -0,0 +1,122 @@
+/**
+ * Daily log endpoints
+ *
+ * Provides CRUD access to daily conversation summaries.
+ * Logs are stored as markdown files in $DATA_DIR/daily-logs/YYYY-MM-DD.md.
+ *
+ * Endpoints:
+ *   GET    /api/daily-logs          - List all logs (date + size)
+ *   POST   /api/daily-logs          - Create a new daily log
+ *   GET    /api/daily-logs/:date    - Get a specific day's log
+ *   PUT    /api/daily-logs/:date    - Update a daily log
+ *   DELETE /api/daily-logs/:date    - Delete a specific day's log
+ */
+
+const { verifyToken } = require('../lib/auth')
+const dailyLogStore = require('../stores/daily-log-store')
+
+/**
+ * Register daily log routes as Fastify plugin
+ * @param {import('fastify').FastifyInstance} fastify
+ */
+async function dailyLogRoutes(fastify) {
+
+  // GET /api/daily-logs - List all logs
+  fastify.get('/api/daily-logs', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const logs = await dailyLogStore.listLogs()
+    return { success: true, logs }
+  })
+
+  // POST /api/daily-logs - Create a new daily log
+  fastify.post('/api/daily-logs', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { date, content } = request.body || {}
+    if (!date || !content) {
+      reply.code(400)
+      return { success: false, error: 'date and content are required' }
+    }
+
+    // Check if log already exists
+    const existing = await dailyLogStore.loadLog(date)
+    if (existing !== null) {
+      reply.code(409)
+      return { success: false, error: 'Log already exists for this date. Use PUT to update.' }
+    }
+
+    await dailyLogStore.saveLog(date, content)
+    console.log(`[DailyLogs] Created log: ${date}`)
+    return { success: true, log: { date, content } }
+  })
+
+  // GET /api/daily-logs/:date - Get a specific day's log
+  fastify.get('/api/daily-logs/:date', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { date } = request.params
+    const content = await dailyLogStore.loadLog(date)
+    if (content === null) {
+      reply.code(404)
+      return { success: false, error: 'Log not found' }
+    }
+
+    return { success: true, log: { date, content } }
+  })
+
+  // PUT /api/daily-logs/:date - Update a daily log
+  fastify.put('/api/daily-logs/:date', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { date } = request.params
+    const { content } = request.body || {}
+    if (!content) {
+      reply.code(400)
+      return { success: false, error: 'content is required' }
+    }
+
+    // Check if log exists
+    const existing = await dailyLogStore.loadLog(date)
+    if (existing === null) {
+      reply.code(404)
+      return { success: false, error: 'Log not found' }
+    }
+
+    await dailyLogStore.saveLog(date, content)
+    console.log(`[DailyLogs] Updated log: ${date}`)
+    return { success: true, log: { date, content } }
+  })
+
+  // DELETE /api/daily-logs/:date - Delete a specific day's log
+  fastify.delete('/api/daily-logs/:date', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { date } = request.params
+    const deleted = await dailyLogStore.deleteLog(date)
+    if (!deleted) {
+      reply.code(404)
+      return { success: false, error: 'Log not found' }
+    }
+
+    console.log(`[DailyLogs] Deleted log: ${date}`)
+    return { success: true }
+  })
+}
+
+module.exports = { dailyLogRoutes }

package/core/routes/memory.js

@@ -0,0 +1,112 @@
+/**
+ * Memory management endpoints
+ *
+ * Provides CRUD for the minion's long-term memory entries.
+ * Memory is stored as markdown files with YAML frontmatter in $DATA_DIR/memory/.
+ *
+ * Endpoints:
+ *   GET    /api/memory          - List all memory entries
+ *   GET    /api/memory/:id      - Get a single entry
+ *   POST   /api/memory          - Create a new entry
+ *   PUT    /api/memory/:id      - Update an entry
+ *   DELETE /api/memory/:id      - Delete an entry
+ */
+
+const { verifyToken } = require('../lib/auth')
+const memoryStore = require('../stores/memory-store')
+
+/**
+ * Register memory routes as Fastify plugin
+ * @param {import('fastify').FastifyInstance} fastify
+ */
+async function memoryRoutes(fastify) {
+
+  // GET /api/memory - List all entries
+  fastify.get('/api/memory', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const entries = await memoryStore.listEntries()
+    return { success: true, entries }
+  })
+
+  // GET /api/memory/:id - Get a single entry
+  fastify.get('/api/memory/:id', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const entry = await memoryStore.loadEntry(request.params.id)
+    if (!entry) {
+      reply.code(404)
+      return { success: false, error: 'Entry not found' }
+    }
+
+    return { success: true, entry }
+  })
+
+  // POST /api/memory - Create a new entry
+  fastify.post('/api/memory', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { title, category, content } = request.body || {}
+    if (!title || !content) {
+      reply.code(400)
+      return { success: false, error: 'title and content are required' }
+    }
+
+    const entry = await memoryStore.saveEntry({ title, category, content })
+    console.log(`[Memory] Created entry: ${entry.id} (${entry.title})`)
+    return { success: true, entry }
+  })
+
+  // PUT /api/memory/:id - Update an entry
+  fastify.put('/api/memory/:id', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const existing = await memoryStore.loadEntry(request.params.id)
+    if (!existing) {
+      reply.code(404)
+      return { success: false, error: 'Entry not found' }
+    }
+
+    const { title, category, content } = request.body || {}
+    const entry = await memoryStore.saveEntry({
+      id: request.params.id,
+      title: title || existing.title,
+      category: category || existing.category,
+      content: content !== undefined ? content : existing.content,
+    })
+
+    console.log(`[Memory] Updated entry: ${entry.id} (${entry.title})`)
+    return { success: true, entry }
+  })
+
+  // DELETE /api/memory/:id - Delete an entry
+  fastify.delete('/api/memory/:id', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const deleted = await memoryStore.deleteEntry(request.params.id)
+    if (!deleted) {
+      reply.code(404)
+      return { success: false, error: 'Entry not found' }
+    }
+
+    console.log(`[Memory] Deleted entry: ${request.params.id}`)
+    return { success: true }
+  })
+}
+
+module.exports = { memoryRoutes }

package/core/stores/daily-log-store.js

@@ -0,0 +1,182 @@
+/**
+ * Daily Log Store
+ * Stores daily conversation summaries as markdown files.
+ * One file per day: $DATA_DIR/daily-logs/YYYY-MM-DD.md
+ *
+ * These logs serve as short-term memory (recent days),
+ * bridging working memory (chat session) and long-term memory (memory-store).
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+
+const { config } = require('../config')
+const { DATA_DIR } = require('../lib/platform')
+
+/**
+ * Resolve daily logs directory path
+ */
+function getLogsDir() {
+  try {
+    require('fs').accessSync(DATA_DIR)
+    return path.join(DATA_DIR, 'daily-logs')
+  } catch {
+    return path.join(config.HOME_DIR, 'daily-logs')
+  }
+}
+
+const LOGS_DIR = getLogsDir()
+
+/**
+ * Ensure the daily-logs directory exists
+ */
+async function ensureDir() {
+  await fs.mkdir(LOGS_DIR, { recursive: true })
+}
+
+/**
+ * Validate date string format (YYYY-MM-DD)
+ */
+function isValidDate(date) {
+  return /^\d{4}-\d{2}-\d{2}$/.test(date)
+}
+
+/**
+ * List all daily logs with date and file size.
+ * @returns {Promise<Array<{ date: string, size: number }>>} Sorted descending by date
+ */
+async function listLogs() {
+  await ensureDir()
+  let files
+  try {
+    files = await fs.readdir(LOGS_DIR)
+  } catch {
+    return []
+  }
+
+  const logs = []
+  for (const file of files) {
+    if (!file.endsWith('.md')) continue
+    const date = file.replace('.md', '')
+    if (!isValidDate(date)) continue
+    try {
+      const stat = await fs.stat(path.join(LOGS_DIR, file))
+      logs.push({ date, size: stat.size })
+    } catch {
+      // Skip unreadable
+    }
+  }
+
+  // Sort by date descending (most recent first)
+  logs.sort((a, b) => b.date.localeCompare(a.date))
+  return logs
+}
+
+/**
+ * Load a specific day's log.
+ * @param {string} date - YYYY-MM-DD format
+ * @returns {Promise<string|null>} Log content or null
+ */
+async function loadLog(date) {
+  if (!isValidDate(date)) return null
+  try {
+    return await fs.readFile(path.join(LOGS_DIR, `${date}.md`), 'utf-8')
+  } catch (err) {
+    if (err.code === 'ENOENT') return null
+    console.error(`[DailyLogStore] Failed to load log ${date}: ${err.message}`)
+    return null
+  }
+}
+
+/**
+ * Save a daily log. Overwrites existing log for the same date.
+ * @param {string} date - YYYY-MM-DD format
+ * @param {string} content - Markdown content
+ */
+async function saveLog(date, content) {
+  if (!isValidDate(date)) {
+    throw new Error(`Invalid date format: ${date}. Expected YYYY-MM-DD.`)
+  }
+  await ensureDir()
+  await fs.writeFile(path.join(LOGS_DIR, `${date}.md`), content, 'utf-8')
+}
+
+/**
+ * Delete a daily log.
+ * @param {string} date - YYYY-MM-DD format
+ * @returns {Promise<boolean>}
+ */
+async function deleteLog(date) {
+  if (!isValidDate(date)) return false
+  try {
+    await fs.unlink(path.join(LOGS_DIR, `${date}.md`))
+    return true
+  } catch (err) {
+    if (err.code === 'ENOENT') return false
+    console.error(`[DailyLogStore] Failed to delete log ${date}: ${err.message}`)
+    return false
+  }
+}
+
+/**
+ * Get the most recent N days of logs.
+ * @param {number} days - Number of recent days to fetch
+ * @returns {Promise<Array<{ date: string, content: string }>>}
+ */
+async function getRecentLogs(days = 3) {
+  const all = await listLogs()
+  const recent = all.slice(0, days)
+
+  const results = []
+  for (const { date } of recent) {
+    const content = await loadLog(date)
+    if (content) {
+      results.push({ date, content })
+    }
+  }
+  return results
+}
+
+/**
+ * Get a context snippet of recent daily logs for chat injection.
+ * @param {number} days - Number of days to include
+ * @param {number} maxChars - Maximum total characters
+ * @returns {Promise<string>}
+ */
+async function getContextSnippet(days = 3, maxChars = 1500) {
+  const logs = await getRecentLogs(days)
+  if (logs.length === 0) return ''
+
+  const parts = []
+  let totalLen = 0
+
+  for (const log of logs) {
+    const header = `### ${log.date}`
+    const content = log.content.substring(0, Math.floor(maxChars / days))
+    const section = `${header}\n${content}`
+
+    if (totalLen + section.length > maxChars) {
+      // Add truncated version
+      const remaining = maxChars - totalLen
+      if (remaining > 50) {
+        parts.push(section.substring(0, remaining) + '...')
+      }
+      break
+    }
+    parts.push(section)
+    totalLen += section.length + 2
+  }
+
+  return parts.join('\n\n')
+}
+
+module.exports = {
+  ensureDir,
+  listLogs,
+  loadLog,
+  saveLog,
+  deleteLog,
+  getRecentLogs,
+  getContextSnippet,
+  LOGS_DIR,
+}