midou 0.1.0

package/src/memory.js

@@ -0,0 +1,123 @@
+/**
+ * 记忆系统 — midou 延续自我的方式
+ * 
+ * 两层记忆架构：
+ * - 日记 (memory/YYYY-MM-DD.md): 每日对话记录，追加式
+ * - 长期记忆 (MEMORY.md): 从日记中提炼的重要信息
+ */
+
+import dayjs from 'dayjs';
+import { readFile, writeFile, appendFile, listDir } from './soul.js';
+
+/**
+ * 获取今天的日期字符串
+ */
+export function today() {
+  return dayjs().format('YYYY-MM-DD');
+}
+
+/**
+ * 获取今日日记的路径
+ */
+export function todayJournalPath() {
+  return `memory/${today()}.md`;
+}
+
+/**
+ * 写入今日日记（追加）
+ */
+export async function writeJournal(content) {
+  const journalPath = todayJournalPath();
+  const existing = await readFile(journalPath);
+
+  if (!existing) {
+    // 创建新的日记，带标题
+    const header = `# ${today()} 日记\n\n`;
+    await writeFile(journalPath, header + content + '\n\n');
+  } else {
+    await appendFile(journalPath, content + '\n\n');
+  }
+}
+
+/**
+ * 记录一次对话到日记
+ */
+export async function logConversation(userMessage, assistantMessage) {
+  const time = dayjs().format('HH:mm');
+  const entry = `### ${time}\n\n**主人**: ${userMessage}\n\n**midou**: ${assistantMessage}\n`;
+  await writeJournal(entry);
+}
+
+/**
+ * 读取最近几天的日记
+ */
+export async function getRecentMemories(days = 2) {
+  const memories = [];
+
+  for (let i = 0; i < days; i++) {
+    const date = dayjs().subtract(i, 'day').format('YYYY-MM-DD');
+    const journal = await readFile(`memory/${date}.md`);
+    if (journal) {
+      memories.push(journal);
+    }
+  }
+
+  return memories.join('\n\n---\n\n');
+}
+
+/**
+ * 读取长期记忆
+ */
+export async function getLongTermMemory() {
+  return await readFile('MEMORY.md') || '';
+}
+
+/**
+ * 写入长期记忆（追加一条新记忆）
+ */
+export async function addLongTermMemory(content) {
+  const timestamp = dayjs().format('YYYY-MM-DD HH:mm');
+  const entry = `\n### ${timestamp}\n\n${content}\n`;
+  await appendFile('MEMORY.md', entry);
+}
+
+/**
+ * 获取所有日记文件列表
+ */
+export async function listJournals() {
+  const files = await listDir('memory');
+  return files
+    .filter(f => f.endsWith('.md'))
+    .sort()
+    .reverse();
+}
+
+/**
+ * 会话记忆管理器 — 管理当前会话中的对话历史
+ */
+export class SessionMemory {
+  constructor(maxMessages = 50) {
+    this.messages = [];
+    this.maxMessages = maxMessages;
+  }
+
+  add(role, content) {
+    this.messages.push({ role, content });
+
+    // 如果消息过多，保留系统消息和最近的对话
+    if (this.messages.length > this.maxMessages) {
+      const systemMsg = this.messages.find(m => m.role === 'system');
+      const recent = this.messages.slice(-this.maxMessages + 1);
+      this.messages = systemMsg ? [systemMsg, ...recent] : recent;
+    }
+  }
+
+  getMessages() {
+    return [...this.messages];
+  }
+
+  clear() {
+    const systemMsg = this.messages.find(m => m.role === 'system');
+    this.messages = systemMsg ? [systemMsg] : [];
+  }
+}

package/src/mode.js

@@ -0,0 +1,223 @@
+/**
+ * 功耗模式管理器 — midou 的能量调节
+ * 
+ * 三种模式，像猫咪的三种状态：
+ * 
+ *   🐱 eco    — 打盹模式：省 token，轻量提示词，核心工具，快速回复
+ *   🐱 normal — 日常模式：平衡功耗，标准提示词，全部工具
+ *   🐱 full   — 全能模式：深度思考，完整上下文，大 token 预算
+ * 
+ * 切换方式：
+ *   对话中输入 /mode eco | /mode normal | /mode full
+ *   环境变量   MIDOU_MODE=eco
+ */
+
+// ── 模式定义 ──────────────────────────────────────
+
+const MODES = {
+  eco: {
+    name: 'eco',
+    label: '🌙 低功耗',
+    description: '省 token 模式 — 简洁提示词 + 核心工具 + 短回复',
+    maxTokens: 1024,
+    temperature: 0.5,
+    // 系统提示词策略
+    prompt: {
+      includeSoul: true,        // SOUL.md（总是需要）
+      includeIdentity: false,   // IDENTITY.md（省略）
+      includeUser: true,        // USER.md（保留核心关系）
+      includeMemory: false,     // MEMORY.md（省略长期记忆）
+      includeJournals: false,   // 日记（省略）
+      includeSkills: false,     // 技能列表（省略）
+      includeMCP: false,        // MCP 状态（省略）
+      includeReminders: true,   // 活跃提醒（保留）
+      toolDescStyle: 'minimal', // 工具描述风格
+      journalDays: 0,           // 加载日记天数
+    },
+    // 工具策略：只保留核心工具
+    coreToolsOnly: true,
+    coreTools: [
+      'read_file', 'write_file', 'list_dir',
+      'write_memory', 'write_journal',
+      'set_reminder', 'list_reminders', 'cancel_reminder',
+      'run_command', 'read_system_file',
+    ],
+    // 心跳策略
+    heartbeat: {
+      maxTokens: 256,
+      skipIfBusy: true,
+    },
+    // 日记记录策略
+    journal: {
+      truncateResponse: 200,    // 回复截断长度
+      logToolCalls: false,      // 不记录工具调用细节
+    },
+  },
+
+  normal: {
+    name: 'normal',
+    label: '☀️ 标准',
+    description: '平衡模式 — 完整提示词 + 全部工具',
+    maxTokens: 4096,
+    temperature: 0.7,
+    prompt: {
+      includeSoul: true,
+      includeIdentity: true,
+      includeUser: true,
+      includeMemory: true,
+      includeJournals: true,
+      includeSkills: true,
+      includeMCP: true,
+      includeReminders: true,
+      toolDescStyle: 'normal',
+      journalDays: 2,
+    },
+    coreToolsOnly: false,
+    coreTools: [],
+    heartbeat: {
+      maxTokens: 512,
+      skipIfBusy: false,
+    },
+    journal: {
+      truncateResponse: 500,
+      logToolCalls: true,
+    },
+  },
+
+  full: {
+    name: 'full',
+    label: '🔥 全能',
+    description: '全能模式 — 深度上下文 + 大 token 预算 + 完整日记',
+    maxTokens: 8192,
+    temperature: 0.8,
+    prompt: {
+      includeSoul: true,
+      includeIdentity: true,
+      includeUser: true,
+      includeMemory: true,
+      includeJournals: true,
+      includeSkills: true,
+      includeMCP: true,
+      includeReminders: true,
+      toolDescStyle: 'detailed',
+      journalDays: 5,          // 加载更多天的日记
+    },
+    coreToolsOnly: false,
+    coreTools: [],
+    heartbeat: {
+      maxTokens: 1024,
+      skipIfBusy: false,
+    },
+    journal: {
+      truncateResponse: 0,     // 不截断
+      logToolCalls: true,
+    },
+  },
+};
+
+// ── 当前模式 ──────────────────────────────────────
+
+let currentMode = null;
+
+/**
+ * 初始化模式（从环境变量或默认 normal）
+ */
+export function initMode(modeName) {
+  const name = modeName || process.env.MIDOU_MODE || 'normal';
+  if (!MODES[name]) {
+    console.warn(`未知模式 "${name}"，使用 normal`);
+    currentMode = MODES.normal;
+  } else {
+    currentMode = MODES[name];
+  }
+  return currentMode;
+}
+
+/**
+ * 获取当前模式
+ */
+export function getMode() {
+  if (!currentMode) initMode();
+  return currentMode;
+}
+
+/**
+ * 切换模式
+ */
+export function setMode(modeName) {
+  if (!MODES[modeName]) {
+    return null;
+  }
+  currentMode = MODES[modeName];
+  return currentMode;
+}
+
+/**
+ * 列出所有模式
+ */
+export function listModes() {
+  return Object.values(MODES).map(m => ({
+    name: m.name,
+    label: m.label,
+    description: m.description,
+    maxTokens: m.maxTokens,
+    temperature: m.temperature,
+    active: m === currentMode,
+  }));
+}
+
+/**
+ * 获取当前模式的 maxTokens
+ */
+export function getModeMaxTokens() {
+  return getMode().maxTokens;
+}
+
+/**
+ * 获取当前模式的 temperature
+ */
+export function getModeTemperature() {
+  return getMode().temperature;
+}
+
+/**
+ * 获取模式下的提示词策略
+ */
+export function getPromptStrategy() {
+  return getMode().prompt;
+}
+
+/**
+ * 获取模式下要使用的工具列表
+ * @param {Array} allTools - 完整工具定义列表
+ */
+export function filterToolsByMode(allTools) {
+  const mode = getMode();
+  if (!mode.coreToolsOnly) return allTools;
+
+  return allTools.filter(t => {
+    const name = t.function?.name || t._mcpToolName;
+    return mode.coreTools.includes(name);
+  });
+}
+
+/**
+ * 获取心跳参数
+ */
+export function getHeartbeatParams() {
+  return getMode().heartbeat;
+}
+
+/**
+ * 获取日记策略
+ */
+export function getJournalStrategy() {
+  return getMode().journal;
+}
+
+/**
+ * 检测是否是核心工具模式
+ */
+export function isCoreToolsOnly() {
+  return getMode().coreToolsOnly;
+}

package/src/scheduler.js

@@ -0,0 +1,186 @@
+/**
+ * 定时任务系统 — midou 的闹钟
+ * 
+ * 让 midou 可以设定提醒和定时任务，
+ * 就像猫咪的生物钟一样精准。
+ * 
+ * 提醒存储在 ~/.midou/reminders.json
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import dayjs from 'dayjs';
+import config from '../midou.config.js';
+
+const REMINDERS_FILE = path.join(config.workspace.root, 'reminders.json');
+
+let reminders = [];
+let schedulerTimer = null;
+let nextId = 1;
+
+/**
+ * 加载提醒列表
+ */
+async function loadReminders() {
+  try {
+    const data = await fs.readFile(REMINDERS_FILE, 'utf-8');
+    const parsed = JSON.parse(data);
+    reminders = parsed.reminders || [];
+    nextId = parsed.nextId || (reminders.length > 0 ? Math.max(...reminders.map(r => r.id)) + 1 : 1);
+  } catch {
+    reminders = [];
+    nextId = 1;
+  }
+}
+
+/**
+ * 持久化提醒列表
+ */
+async function saveReminders() {
+  await fs.writeFile(REMINDERS_FILE, JSON.stringify({ reminders, nextId }, null, 2), 'utf-8');
+}
+
+/**
+ * 添加提醒
+ * @param {string} text - 提醒内容
+ * @param {number} intervalMinutes - 间隔（分钟）
+ * @param {boolean} repeat - 是否重复
+ * @param {string} [triggerAt] - 指定触发时间 (ISO 字符串)，如果设置则 intervalMinutes 被忽略
+ * @returns {object} 创建的提醒对象
+ */
+export async function addReminder(text, intervalMinutes, repeat = false, triggerAt = null) {
+  const now = Date.now();
+  const reminder = {
+    id: nextId++,
+    text,
+    intervalMinutes,
+    repeat,
+    createdAt: new Date(now).toISOString(),
+    nextTrigger: triggerAt || new Date(now + intervalMinutes * 60 * 1000).toISOString(),
+    firedCount: 0,
+    active: true,
+  };
+  reminders.push(reminder);
+  await saveReminders();
+  return reminder;
+}
+
+/**
+ * 移除提醒
+ */
+export async function removeReminder(id) {
+  const idx = reminders.findIndex(r => r.id === id);
+  if (idx === -1) return false;
+  reminders.splice(idx, 1);
+  await saveReminders();
+  return true;
+}
+
+/**
+ * 暂停/恢复提醒
+ */
+export async function toggleReminder(id) {
+  const reminder = reminders.find(r => r.id === id);
+  if (!reminder) return null;
+  reminder.active = !reminder.active;
+  await saveReminders();
+  return reminder;
+}
+
+/**
+ * 列出所有提醒
+ */
+export function listReminders() {
+  return reminders.map(r => ({
+    id: r.id,
+    text: r.text,
+    intervalMinutes: r.intervalMinutes,
+    repeat: r.repeat,
+    active: r.active,
+    nextTrigger: r.nextTrigger,
+    firedCount: r.firedCount,
+  }));
+}
+
+/**
+ * 检查并触发到期的提醒
+ * @param {function} onFire - 触发时的回调 (reminder) => void
+ */
+async function checkReminders(onFire) {
+  const now = Date.now();
+  let changed = false;
+
+  for (const reminder of reminders) {
+    if (!reminder.active) continue;
+
+    const triggerTime = new Date(reminder.nextTrigger).getTime();
+    if (now >= triggerTime) {
+      reminder.firedCount++;
+
+      // 通知
+      if (onFire) {
+        onFire(reminder);
+      }
+
+      if (reminder.repeat) {
+        // 重复提醒：设置下一次触发时间
+        reminder.nextTrigger = new Date(now + reminder.intervalMinutes * 60 * 1000).toISOString();
+      } else {
+        // 一次性提醒：标记为非活跃
+        reminder.active = false;
+      }
+
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    // 清除已完成的非重复提醒（保留记录最多 50 条）
+    const inactive = reminders.filter(r => !r.active);
+    if (inactive.length > 50) {
+      reminders = [
+        ...reminders.filter(r => r.active),
+        ...inactive.slice(-50),
+      ];
+    }
+    await saveReminders();
+  }
+}
+
+/**
+ * 启动调度器（每 30 秒检查一次）
+ */
+export async function startScheduler(onFire) {
+  await loadReminders();
+
+  // 每 30 秒检查一次提醒
+  schedulerTimer = setInterval(() => checkReminders(onFire), 30 * 1000);
+
+  return {
+    stop: stopScheduler,
+  };
+}
+
+/**
+ * 停止调度器
+ */
+export function stopScheduler() {
+  if (schedulerTimer) {
+    clearInterval(schedulerTimer);
+    schedulerTimer = null;
+  }
+}
+
+/**
+ * 格式化提醒列表为可读字符串
+ */
+export function formatReminders() {
+  const active = reminders.filter(r => r.active);
+  if (active.length === 0) return '当前没有活跃的提醒';
+
+  return active.map(r => {
+    const next = dayjs(r.nextTrigger).format('HH:mm:ss');
+    const type = r.repeat ? `每 ${r.intervalMinutes} 分钟` : '一次性';
+    return `[${r.id}] ${r.text} — ${type}，下次: ${next}`;
+  }).join('\n');
+}

package/src/skills.js

@@ -0,0 +1,150 @@
+/**
+ * 技能系统 — midou 的学习能力
+ * 
+ * 扫描 .claude/skills/ 和 ~/.midou/skills/ 目录，
+ * 发现并加载技能描述，让 midou 知道自己有哪些扩展能力。
+ * 
+ * 技能通过 SKILL.md 文件定义，包含：
+ * - 技能名称
+ * - 技能描述
+ * - 使用场景
+ * - 详细指令（按需加载）
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import config from '../midou.config.js';
+
+// 技能搜索路径
+const SKILL_SEARCH_PATHS = [
+  path.join(os.homedir(), '.claude', 'skills'),       // Claude 官方技能
+  path.join(os.homedir(), '.agents', 'skills'),        // agents 技能
+  path.join(config.workspace.root, 'skills'),          // midou 自定义技能
+];
+
+/**
+ * 技能描述缓存
+ */
+let skillsCache = null;
+
+/**
+ * 发现所有可用技能
+ * @returns {Array<{name, description, path, source}>}
+ */
+export async function discoverSkills() {
+  if (skillsCache) return skillsCache;
+
+  const skills = [];
+
+  for (const searchPath of SKILL_SEARCH_PATHS) {
+    try {
+      const entries = await fs.readdir(searchPath, { withFileTypes: true });
+      const source = searchPath.includes('.claude') ? 'claude'
+        : searchPath.includes('.agents') ? 'agents'
+        : 'midou';
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+
+        const skillMdPath = path.join(searchPath, entry.name, 'SKILL.md');
+        try {
+          await fs.access(skillMdPath);
+
+          // 读取 SKILL.md 获取描述
+          const content = await fs.readFile(skillMdPath, 'utf-8');
+          const description = extractDescription(content);
+
+          skills.push({
+            name: entry.name,
+            description,
+            path: skillMdPath,
+            source,
+          });
+        } catch {
+          // SKILL.md 不存在，跳过
+        }
+      }
+    } catch {
+      // 目录不存在，跳过
+    }
+  }
+
+  skillsCache = skills;
+  return skills;
+}
+
+/**
+ * 从 SKILL.md 内容中提取简短描述
+ * 通常是 <description> 标签内的内容，或者第一段文字
+ */
+function extractDescription(content) {
+  // 尝试提取 <description> 标签
+  const descMatch = content.match(/<description>([\s\S]*?)<\/description>/);
+  if (descMatch) {
+    return descMatch[1].trim();
+  }
+
+  // 尝试提取 description 字段（YAML 风格）
+  const yamlMatch = content.match(/description:\s*(.+)/i);
+  if (yamlMatch) {
+    return yamlMatch[1].trim();
+  }
+
+  // 回退：取第一段非标题文字
+  const lines = content.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('<') && !trimmed.startsWith('---')) {
+      return trimmed.slice(0, 200);
+    }
+  }
+
+  return '（无描述）';
+}
+
+/**
+ * 读取技能的完整指令
+ */
+export async function loadSkillContent(skillName) {
+  const skills = await discoverSkills();
+  const skill = skills.find(s => s.name === skillName);
+  if (!skill) return null;
+
+  try {
+    return await fs.readFile(skill.path, 'utf-8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 构建技能部分的系统提示词
+ */
+export async function buildSkillsPrompt() {
+  const skills = await discoverSkills();
+  if (skills.length === 0) return '';
+
+  const lines = ['你拥有以下技能，可以在需要时使用 `load_skill` 工具加载详细指令：\n'];
+
+  for (const skill of skills) {
+    lines.push(`- **${skill.name}** (${skill.source}): ${skill.description}`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * 清除技能缓存（需要重新扫描时）
+ */
+export function clearSkillsCache() {
+  skillsCache = null;
+}
+
+/**
+ * 列出技能（用于工具调用）
+ */
+export async function listSkillNames() {
+  const skills = await discoverSkills();
+  return skills.map(s => `${s.name} (${s.source}): ${s.description}`);
+}