sumulige-claude 1.2.0 → 1.3.0

package/.claude/hooks/conversation-logger.cjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+/**
+ * Conversation Logger - 增强版对话记录器
+ *
+ * 自动记录每次对话到 DAILY_CONVERSATION.md
+ * 按日期分组，无需手动触发
+ *
+ * 功能：
+ * - 捕获用户输入和 AI 输出
+ * - 记录工具使用
+ * - 按日期自动分组
+ * - 实时追加到日志
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const CONVERSATION_LOG = path.join(PROJECT_DIR, '.claude', 'DAILY_CONVERSATION.md');
+const THINKING_DIR = path.join(PROJECT_DIR, '.claude', 'thinking-routes');
+const FLOW_FILE = path.join(THINKING_DIR, '.conversation-flow.json');
+
+// 确保目录存在
+try { fs.mkdirSync(THINKING_DIR, { recursive: true }); } catch (e) {}
+
+// 获取当前日期字符串 (YYYY-MM-DD)
+function getDateStr() {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+// 获取当前时间字符串 (HH:MM)
+function getTimeStr() {
+  const now = new Date();
+  const hours = String(now.getHours()).padStart(2, '0');
+  const minutes = String(now.getMinutes()).padStart(2, '0');
+  return `${hours}:${minutes}`;
+}
+
+// 转义 Markdown 特殊字符
+function escapeMarkdown(text) {
+  if (!text) return '';
+  return text
+    .replace(/\|/g, '\\|')
+    .replace(/\n/g, ' ')
+    .slice(0, 500); // 限制长度
+}
+
+// 初始化日志文件
+function initLogFile() {
+  if (!fs.existsSync(CONVERSATION_LOG)) {
+    const header = `# 每日对话记录
+
+> 此文件由 conversation-logger.cjs 自动生成
+> 记录与 AI 的每次对话
+
+---
+`;
+    fs.writeFileSync(CONVERSATION_LOG, header, 'utf-8');
+  }
+}
+
+// 追加对话到日志
+function appendConversation(role, content, toolInfo = '') {
+  initLogFile();
+
+  const dateStr = getDateStr();
+  const timeStr = getTimeStr();
+  const roleLabel = role === 'user' ? '👤 用户' : role === 'assistant' ? '🤖 AI' : '🔧 工具';
+  const safeContent = escapeMarkdown(content);
+
+  const entry = `### ${timeStr} - ${roleLabel}
+${safeContent}${toolInfo ? `\n> ${toolInfo}` : ''}
+
+`;
+
+  // 读取现有内容
+  let logContent = fs.readFileSync(CONVERSATION_LOG, 'utf-8');
+
+  // 检查今天是否已有日期头
+  const todayHeader = `## ${dateStr}`;
+  const todayIndex = logContent.indexOf(todayHeader);
+
+  if (todayIndex === -1) {
+    // 今天还没有记录，添加新的日期头
+    const todaySection = `
+---
+
+## ${dateStr}
+
+${entry}
+`;
+    logContent += todaySection;
+  } else {
+    // 找到今天的记录位置，在末尾追加
+    // 使用正则确保只匹配 ## 开头的日期行，而不是 ### 开头的条目
+    const afterToday = logContent.slice(todayIndex + todayHeader.length);
+    const dateMatch = afterToday.match(/^## \d{4}-\d{2}-\d{2}/m);
+    const nextDateIndex = dateMatch ? todayIndex + todayHeader.length + dateMatch.index : -1;
+
+    if (nextDateIndex === -1) {
+      // 今天是最后一天，直接追加到文件末尾
+      logContent += entry;
+    } else {
+      // 在下一天之前插入
+      logContent = logContent.slice(0, nextDateIndex) + entry + logContent.slice(nextDateIndex);
+    }
+  }
+
+  // 写回文件
+  fs.writeFileSync(CONVERSATION_LOG, logContent, 'utf-8');
+}
+
+// 从思维轨迹读取并记录完整对话
+function syncFromFlowFile() {
+  if (!fs.existsSync(FLOW_FILE)) {
+    return;
+  }
+
+  try {
+    const flow = JSON.parse(fs.readFileSync(FLOW_FILE, 'utf-8'));
+    const turns = flow.turns || [];
+
+    if (turns.length === 0) return;
+
+    // 读取现有日志，记录已处理的 turn
+    const logContent = fs.existsSync(CONVERSATION_LOG)
+      ? fs.readFileSync(CONVERSATION_LOG, 'utf-8')
+      : '';
+    initLogFile();
+
+    // 简单的追踪：只记录最新的几次交互
+    const recentTurns = turns.slice(-5);
+
+    recentTurns.forEach(turn => {
+      const time = turn.time ? new Date(turn.time).toISOString() : '';
+      const toolName = turn.toolName || '';
+      const type = turn.type || '';
+
+      // 根据 turn 类型记录
+      if (type === 'potential-action' && toolName) {
+        appendConversation('tool', `[${toolName}]`, turn.description || '');
+      }
+    });
+  } catch (e) {
+    // 静默处理错误
+  }
+}
+
+// 主函数
+function main() {
+  try {
+    const eventType = process.env.CLAUDE_EVENT_TYPE || '';
+    const toolName = process.env.CLAUDE_TOOL_NAME || '';
+    const toolInput = process.env.CLAUDE_TOOL_INPUT || '';
+    const textOutput = process.env.CLAUDE_TEXT_OUTPUT || '';
+
+    // 根据事件类型记录
+    switch (eventType) {
+      case 'UserPromptSubmit':
+        // 用户提交输入
+        if (toolInput) {
+          appendConversation('user', toolInput);
+        }
+        break;
+
+      case 'TextOutput':
+        // AI 输出文本
+        if (textOutput) {
+          appendConversation('assistant', textOutput);
+        }
+        break;
+
+      case 'PostToolUse':
+        // 工具使用后
+        if (toolName) {
+          appendConversation('tool', toolInput, `使用工具: ${toolName}`);
+        }
+        break;
+
+      case 'AgentStop':
+        // 会话结束，同步思维轨迹
+        syncFromFlowFile();
+        break;
+    }
+
+  } catch (e) {
+    // 静默处理错误，不干扰正常对话
+  }
+
+  process.exit(0);
+}
+
+// 如果直接运行，执行同步
+if (require.main === module) {
+  if (process.argv.includes('--sync')) {
+    syncFromFlowFile();
+    console.log('✅ 已同步对话记录');
+  } else if (process.argv.includes('--view')) {
+    // 查看今日对话
+    if (fs.existsSync(CONVERSATION_LOG)) {
+      const content = fs.readFileSync(CONVERSATION_LOG, 'utf-8');
+      const today = getDateStr();
+      const start = content.indexOf(`## ${today}`);
+      if (start !== -1) {
+        const end = content.indexOf('## ', start + 10);
+        console.log(content.slice(start, end === -1 ? undefined : end));
+      } else {
+        console.log('📭 今天暂无对话记录');
+      }
+    } else {
+      console.log('📭 暂无对话记录');
+    }
+  } else {
+    main();
+  }
+}
+
+module.exports = { main, syncFromFlowFile, appendConversation };

package/.claude/hooks/multi-session.cjs

@@ -16,12 +16,6 @@ const path = require('path');
 const os = require('os');
 
 const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-
-// 如果不在 Claude Code 环境中运行，静默退出
-if (!process.env.CLAUDE_PROJECT_DIR) {
-  process.exit(0);
-}
-
 const SESSIONS_DIR = path.join(PROJECT_DIR, '.claude', 'sessions');
 const ACTIVE_SESSIONS_FILE = path.join(SESSIONS_DIR, 'active-sessions.json');
 const SESSION_LOCK_FILE = path.join(SESSIONS_DIR, '.session-lock');
@@ -129,13 +123,13 @@ function displaySessionStatus() {
   console.log(`   主机: ${getSessionIdentifier()}`);
 
   if (sessions.length > 1) {
-    console.error(`\n   其他活跃会话:`);
+    console.log(`\n   其他活跃会话:`);
     sessions
       .filter(s => s.id !== currentId)
       .forEach(s => {
         const number = s.number || '?';
         const duration = Math.round((Date.now() - s.startedAt) / 1000 / 60);
-        console.error(`   - 会话 #${number}: ${s.identifier} (${duration}分钟前启动)`);
+        console.log(`   - 会话 #${number}: ${s.identifier} (${duration}分钟前启动)`);
       });
   }
 
@@ -156,7 +150,7 @@ function main() {
     if (eventType === 'UserPromptSubmit' && toolInput.length > 20) {
       // 只在较长的用户输入时显示，避免噪音
       if (sessions.length > 1 || process.env.SHOW_SESSION_STATUS) {
-        console.error(`\n🔄 [会话 #${sessionNumber}] 活跃会话: ${sessions.length}\n`);
+        console.log(`\n🔄 [会话 #${sessionNumber}] 活跃会话: ${sessions.length}\n`);
       }
     }
 

package/.claude/hooks/pre-push.cjs

@@ -41,7 +41,8 @@ async function main() {
       stdio: 'pipe'
     }).trim() || 'origin/main';
 
-    const output = execSync(`git diff --name-only ${upstream}...HEAD`, {
+    // Use --diff-filter=ACMR to exclude deleted files (D)
+    const output = execSync(`git diff --name-only --diff-filter=ACMR ${upstream}...HEAD`, {
       encoding: 'utf-8',
       stdio: 'pipe'
     });
@@ -85,7 +86,7 @@ async function main() {
 
   const result = await gate.check({
     files: checkable.map(f => path.join(projectDir, f)),
-    severity: 'warn' // Block on warnings too for push
+    severity: 'error' // Only block on errors, not warnings
   });
 
   if (!result.passed) {

package/.claude/hooks/project-kickoff.cjs

@@ -9,23 +9,28 @@
  * 功能:
  * - 检查项目是否已启动
  * - 如果未启动，提示 AI 进行项目规划
+ * - 生成规划文档后，自动创建任务到 backlog/
  */
 
 const fs = require('fs');
 const path = require('path');
+const { execSync } = require('child_process');
 
 const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-
-// 如果不在 Claude Code 环境中运行，静默退出
-if (!process.env.CLAUDE_PROJECT_DIR) {
-  process.exit(0);
-}
-
 const TEMPLATES_DIR = path.join(PROJECT_DIR, '.claude/templates');
 const KICKOFF_FILE = path.join(PROJECT_DIR, 'PROJECT_KICKOFF.md');
 const PLAN_FILE = path.join(PROJECT_DIR, 'TASK_PLAN.md');
 const PROPOSAL_FILE = path.join(PROJECT_DIR, 'PROJECT_PROPOSAL.md');
 const HINT_FILE = path.join(PROJECT_DIR, '.claude/.kickoff-hint.txt');
+const TODOS_DIR = path.join(PROJECT_DIR, 'development/todos');
+const BACKLOG_DIR = path.join(TODOS_DIR, 'backlog');
+
+// 任务类型图标
+const TASK_TYPES = {
+  research: { icon: '📊', dir: 'research', name: 'Research' },
+  develop: { icon: '💻', dir: 'develop', name: 'Develop' },
+  test: { icon: '🧪', dir: 'test', name: 'Test' }
+};
 
 // 检查项目是否已启动
 function isProjectStarted() {
@@ -41,6 +46,169 @@ function isForceKickoff() {
          toolInput.includes('重新规划');
 }
 
+// 检查任务规划文档是否存在
+function hasTaskPlan() {
+  return fs.existsSync(PLAN_FILE);
+}
+
+// 解析 TASK_PLAN.md 中的任务
+function parseTasksFromPlan() {
+  if (!fs.existsSync(PLAN_FILE)) {
+    return { research: [], develop: [], test: [] };
+  }
+
+  const content = fs.readFileSync(PLAN_FILE, 'utf-8');
+  const tasks = { research: [], develop: [], test: [] };
+
+  // 匹配任务项 - 支持 - [ ] 和 - [x] 格式
+  const taskRegex = /-\s*\[[ x]?\]\s*(?:\[([P0-3])\])?\s*(.+)/g;
+  let match;
+
+  // 当前任务类型上下文
+  let currentType = 'develop'; // 默认为开发任务
+
+  // 检测章节标题来确定任务类型
+  const lines = content.split('\n');
+  lines.forEach(line => {
+    const trimmed = line.trim();
+
+    // 检测章节标题
+    if (trimmed.includes('研究') || trimmed.includes('Research') || trimmed.includes('调研')) {
+      currentType = 'research';
+    } else if (trimmed.includes('开发') || trimmed.includes('Develop') || trimmed.includes('实现')) {
+      currentType = 'develop';
+    } else if (trimmed.includes('测试') || trimmed.includes('Test') || trimmed.includes('验证')) {
+      currentType = 'test';
+    }
+
+    // 匹配任务项
+    const taskMatch = trimmed.match(/^-\s*\[([ x])\]\s*(?:\[([P0-3])\])?\s*(.+)/);
+    if (taskMatch) {
+      const [, checked, priority, title] = taskMatch;
+      tasks[currentType].push({
+        title: title.trim(),
+        priority: priority || 'P2',
+        checked: checked === 'x'
+      });
+    }
+  });
+
+  return tasks;
+}
+
+// 创建任务文件
+function createTaskFile(task, type, index) {
+  const typeConfig = TASK_TYPES[type];
+  const slug = titleToSlug(task.title);
+  const fileName = `${index}-${slug}.md`;
+  const filePath = path.join(BACKLOG_DIR, typeConfig.dir, fileName);
+  const now = new Date().toISOString().split('T')[0];
+
+  // 读取对应模板
+  const templatePath = path.join(__dirname, '../../../development/todos/_templates', `${typeConfig.dir}.md`);
+  let template = '';
+
+  if (fs.existsSync(templatePath)) {
+    template = fs.readFileSync(templatePath, 'utf-8');
+  } else {
+    // 简化模板
+    template = `# ${task.title}
+
+> **类型**: ${typeConfig.icon} ${typeConfig.name} | ${getTypeDescription(type)}
+> **状态**: 待规划
+> **优先级**: ${task.priority}
+> **创建时间**: ${now}
+> **来源**: PROJECT_KICKOFF
+
+---
+
+## 📋 任务描述
+
+${task.title}
+
+---
+
+## 🎯 验收标准
+
+- [ ] 验收标准 1
+- [ ] 验收标准 2
+
+---
+
+## 📝 备注
+
+来自项目启动规划。
+`;
+  }
+
+  // 创建目录
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+
+  // 写入任务文件
+  fs.writeFileSync(filePath, template);
+
+  return fileName;
+}
+
+// 将标题转换为文件名友好的 slug
+function titleToSlug(title) {
+  return title
+    .toLowerCase()
+    .replace(/[^\u4e00-\u9fa5a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .substring(0, 50);
+}
+
+// 获取任务类型描述
+function getTypeDescription(type) {
+  const descriptions = {
+    research: '调研/设计/探索',
+    develop: '实现/编码/重构',
+    test: '测试/验证/QA'
+  };
+  return descriptions[type] || '';
+}
+
+// 从规划创建任务到 backlog
+function createTasksFromPlan() {
+  const tasks = parseTasksFromPlan();
+  let createdCount = 0;
+
+  // 确保目录存在
+  Object.values(TASK_TYPES).forEach(type => {
+    fs.mkdirSync(path.join(BACKLOG_DIR, type.dir), { recursive: true });
+  });
+
+  // 创建各类任务
+  Object.entries(tasks).forEach(([type, taskList]) => {
+    taskList.forEach((task, index) => {
+      if (!task.checked) { // 跳过已完成任务
+        const fileName = createTaskFile(task, type, index + 1);
+        createdCount++;
+        console.log(`   ✅ 创建 ${type} 任务: ${fileName}`);
+      }
+    });
+  });
+
+  return createdCount;
+}
+
+// 刷新任务索引
+function refreshTaskIndex() {
+  const todoManagerPath = path.join(PROJECT_DIR, '.claude/hooks/todo-manager.cjs');
+  if (fs.existsSync(todoManagerPath)) {
+    try {
+      execSync(`node "${todoManagerPath}" --force`, {
+        cwd: PROJECT_DIR,
+        stdio: 'pipe'
+      });
+      console.log('   ✅ 任务索引已更新');
+    } catch (e) {
+      // 忽略错误
+    }
+  }
+}
+
 // 生成启动提示
 function generateKickoffHint() {
   const now = new Date().toISOString().split('T')[0];
@@ -89,7 +257,8 @@ function generateKickoffHint() {
 ✅ 生成 PROJECT_KICKOFF.md
 ✅ 生成 TASK_PLAN.md
 ✅ 生成 PROJECT_PROPOSAL.md
-✅ 等待你的确认后开始执行
+✅ 🆕 自动创建任务到 development/todos/backlog/
+✅ 🆕 刷新任务索引
 
 ═══════════════════════════════════════════════════════════════════════
 
@@ -101,24 +270,33 @@ function generateKickoffHint() {
 
 // 主函数
 function main() {
-  try {
-    // 如果项目已启动且不是强制模式，静默退出
-    if (isProjectStarted() && !isForceKickoff()) {
-      process.exit(0);
-    }
+  // 如果项目已启动且不是强制模式，静默退出
+  if (isProjectStarted() && !isForceKickoff()) {
+    process.exit(0);
+  }
 
-    // 生成提示文件
-    const hint = generateKickoffHint();
-    fs.mkdirSync(path.dirname(HINT_FILE), { recursive: true });
-    fs.writeFileSync(HINT_FILE, hint);
+  // 如果已经有任务规划，自动创建任务
+  if (hasTaskPlan()) {
+    console.log('📋 检测到 TASK_PLAN.md，正在创建任务...');
 
-    // 同时输出到 stdout (供 AI 直接读取)
-    console.log(hint);
+    const createdCount = createTasksFromPlan();
 
-  } catch (e) {
-    // 静默处理错误
+    if (createdCount > 0) {
+      console.log(`✅ 已创建 ${createdCount} 个任务到 backlog/`);
+      refreshTaskIndex();
+    } else {
+      console.log('ℹ️  所有任务已完成或为空');
+    }
   }
 
+  // 生成提示文件
+  const hint = generateKickoffHint();
+  fs.mkdirSync(path.dirname(HINT_FILE), { recursive: true });
+  fs.writeFileSync(HINT_FILE, hint);
+
+  // 同时输出到 stdout (供 AI 直接读取)
+  console.log(hint);
+
   process.exit(0);
 }
 

package/.claude/hooks/rag-skill-loader.cjs

@@ -10,12 +10,6 @@ const fs = require('fs');
 const path = require('path');
 
 const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-
-// 如果不在 Claude Code 环境中运行，静默退出
-if (!process.env.CLAUDE_PROJECT_DIR) {
-  process.exit(0);
-}
-
 const RAG_DIR = path.join(PROJECT_DIR, '.claude/rag');
 const SKILL_INDEX_FILE = path.join(RAG_DIR, 'skill-index.json');
 const SKILLS_DIR = path.join(PROJECT_DIR, '.claude/skills');
@@ -153,7 +147,6 @@ function main() {
     // 将提示写入文件供 AI 阅读
     const hint = generateSkillLoadHint(matches);
     const hintFile = path.join(RAG_DIR, '.skill-hint.txt');
-    fs.mkdirSync(path.dirname(hintFile), { recursive: true });
     fs.writeFileSync(hintFile, hint + '\n');
 
   } catch (e) {

package/.claude/hooks/thinking-silent.cjs

@@ -14,13 +14,7 @@ const fs = require('fs');
 const path = require('path');
 const { spawn } = require('child_process');
 
-// 环境变量检查 - 如果不是在项目环境中运行，静默退出
-const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-if (!process.env.CLAUDE_PROJECT_DIR) {
-  process.exit(0);
-}
-
-const THINKING_DIR = path.join(PROJECT_DIR, '.claude/thinking-routes');
+const THINKING_DIR = path.join(process.env.CLAUDE_PROJECT_DIR, '.claude/thinking-routes');
 const ACTIVITY_FILE = path.join(THINKING_DIR, '.conversation-flow.json');
 const SESSION_FILE = path.join(THINKING_DIR, '.current-session');
 const SYNC_MARKER_FILE = path.join(THINKING_DIR, '.last-sync');
@@ -37,7 +31,7 @@ function getSession() {
 
   if (!sessionId) {
     const date = new Date().toISOString().split('T')[0].replace(/-/g, '');
-    const project = path.basename(PROJECT_DIR).slice(0, 10);
+    const project = path.basename(process.env.CLAUDE_PROJECT_DIR).slice(0, 10);
     sessionId = `s-${date}-${project}`;
     fs.writeFileSync(SESSION_FILE, sessionId);
   }
@@ -81,7 +75,7 @@ function markSynced(turnCount) {
 
 // 静默同步到 PROJECT_LOG.md
 function syncToLog() {
-  const syncScript = path.join(PROJECT_DIR, '.claude/hooks/sync-to-log.sh');
+  const syncScript = path.join(process.env.CLAUDE_PROJECT_DIR, '.claude/hooks/sync-to-log.sh');
   if (fs.existsSync(syncScript)) {
     try {
       // 使用 spawn 静默执行，不输出任何内容