@geekbeer/minion 2.44.0 → 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/capability-checker.js

@@ -0,0 +1,105 @@
+/**
+ * Capability checker
+ *
+ * Detects MCP servers configured in ~/.mcp.json and available CLI tools.
+ * Results are cached in memory for 5 minutes to avoid excessive filesystem/process checks.
+ * Follows the same caching pattern as llm-checker.js.
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { execSync } = require('child_process')
+const { config } = require('../config')
+const { IS_WINDOWS, buildExtendedPath } = require('./platform')
+
+const CACHE_TTL_MS = 300000 // 5 minutes
+
+let cachedResult = null
+let cachedAt = 0
+
+/**
+ * Detect MCP servers from ~/.mcp.json.
+ * Parses the Claude Code MCP configuration and returns configured server names.
+ * @returns {{ name: string, configured: boolean }[]}
+ */
+function getMcpServers() {
+  const mcpPath = path.join(config.HOME_DIR, '.mcp.json')
+  try {
+    if (!fs.existsSync(mcpPath)) return []
+    const content = fs.readFileSync(mcpPath, 'utf-8')
+    const parsed = JSON.parse(content)
+    const servers = parsed.mcpServers || parsed.servers || {}
+    return Object.keys(servers).map(name => ({
+      name,
+      configured: true,
+    }))
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Check if a CLI tool is available and get its version.
+ * @param {string} name - Tool name (e.g., 'git', 'node')
+ * @returns {{ name: string, available: boolean, version?: string }}
+ */
+function checkTool(name) {
+  const extendedPath = buildExtendedPath(config.HOME_DIR)
+  const env = {
+    ...process.env,
+    HOME: config.HOME_DIR,
+    ...(IS_WINDOWS && { USERPROFILE: config.HOME_DIR }),
+    PATH: extendedPath,
+  }
+  const execOpts = { encoding: 'utf-8', timeout: 5000, stdio: 'pipe', env }
+
+  try {
+    // Check existence
+    const whichCmd = IS_WINDOWS ? 'where' : 'which'
+    execSync(`${whichCmd} ${name}`, execOpts)
+
+    // Get version
+    let version = null
+    try {
+      const out = execSync(`${name} --version`, execOpts).trim()
+      // Extract version number from output (e.g., "git version 2.43.0" → "2.43.0")
+      const match = out.match(/(\d+\.\d+[\.\d]*)/)
+      if (match) version = match[1]
+    } catch {
+      // Tool exists but --version failed, that's ok
+    }
+
+    return { name, available: true, ...(version && { version }) }
+  } catch {
+    return { name, available: false }
+  }
+}
+
+/** CLI tools to detect */
+const TOOL_NAMES = ['git', 'node', 'npx', 'claude', 'docker', 'tmux']
+
+/**
+ * Get all capabilities (MCP servers + CLI tools), cached for 5 minutes.
+ * @returns {{ mcp_servers: { name: string, configured: boolean }[], cli_tools: { name: string, available: boolean, version?: string }[] }}
+ */
+function getCapabilities() {
+  const now = Date.now()
+  if (cachedResult && (now - cachedAt) < CACHE_TTL_MS) {
+    return cachedResult
+  }
+
+  const mcp_servers = getMcpServers()
+  const cli_tools = TOOL_NAMES.map(name => checkTool(name))
+
+  cachedResult = { mcp_servers, cli_tools }
+  cachedAt = now
+  return cachedResult
+}
+
+/** Clear the cached capability status */
+function clearCapabilityCache() {
+  cachedResult = null
+  cachedAt = 0
+}
+
+module.exports = { getCapabilities, clearCapabilityCache }

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/lib/step-poller.js

@@ -94,6 +94,7 @@ async function executeStep(step) {
     assigned_role,
     skill_name,
     revision_feedback,
+    extra_env,
   } = step
 
   console.log(
@@ -151,6 +152,9 @@ async function executeStep(step) {
     if (revision_feedback) {
       runPayload.revision_feedback = revision_feedback
     }
+    if (extra_env && typeof extra_env === 'object') {
+      runPayload.extra_env = extra_env
+    }
 
     const runUrl = `http://localhost:${config.AGENT_PORT || 8080}/api/skills/run`
     const runResp = await fetch(runUrl, {

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/health.js

@@ -11,6 +11,7 @@ const { version } = require('../../package.json')
 const { config, isHqConfigured } = require('../config')
 const { sendHeartbeat } = require('../api')
 const { getLlmServices, isLlmCommandConfigured } = require('../lib/llm-checker')
+const { getCapabilities } = require('../lib/capability-checker')
 
 function maskToken(token) {
   if (!token || token.length < 8) return token ? '***' : ''
@@ -58,6 +59,7 @@ async function healthRoutes(fastify) {
       timestamp: new Date().toISOString(),
       llm_services: getLlmServices(),
       llm_command_configured: isLlmCommandConfigured(),
+      capabilities: getCapabilities(),
       env: {
         HQ_URL: config.HQ_URL || '',
         MINION_ID: config.MINION_ID || '',

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/routes/skills.js

@@ -291,7 +291,7 @@ async function skillRoutes(fastify, opts) {
       return { success: false, error: 'Unauthorized' }
     }
 
-    const { skill_name, execution_id, step_index, workflow_name, role, revision_feedback } = request.body || {}
+    const { skill_name, execution_id, step_index, workflow_name, role, revision_feedback, extra_env } = request.body || {}
 
     if (!skill_name) {
       reply.code(400)
@@ -340,6 +340,7 @@ async function skillRoutes(fastify, opts) {
     const runOptions = {}
     if (role) runOptions.role = role
     if (revision_feedback) runOptions.revisionFeedback = revision_feedback
+    if (extra_env && typeof extra_env === 'object') runOptions.extraEnv = extra_env
 
     // Run asynchronously — respond immediately
     const executionPromise = (async () => {