sumulige-claude 1.0.11 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sumulige-claude",
-  "version": "1.0.11",
+  "version": "1.1.1",
   "description": "The Best Agent Harness for Claude Code",
   "main": "cli.js",
   "bin": {
@@ -14,7 +14,11 @@
     "postinstall": "node cli.js init",
     "sync": "node scripts/sync-external.mjs",
     "update-registry": "node scripts/update-registry.mjs",
-    "sync:all": "npm run sync && npm run update-registry"
+    "sync:all": "npm run sync && npm run update-registry",
+    "release": "standard-version",
+    "release:patch": "standard-version --release-as patch",
+    "release:minor": "standard-version --release-as minor",
+    "release:major": "standard-version --release-as major"
   },
   "keywords": [
     "claude",
@@ -36,11 +40,16 @@
   "engines": {
     "node": ">=16.0.0"
   },
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1"
+  },
   "devDependencies": {
     "jest": "^30.2.0",
     "mock-fs": "^5.5.0",
     "prettier": "^3.7.4",
     "sinon": "^21.0.1",
+    "standard-version": "^9.5.0",
     "yaml": "^2.8.2"
   }
 }

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

@@ -9,10 +9,12 @@
  * 功能:
  * - 检查项目是否已启动
  * - 如果未启动，提示 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();
 const TEMPLATES_DIR = path.join(PROJECT_DIR, '.claude/templates');
@@ -20,6 +22,15 @@ 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() {
@@ -35,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];
@@ -83,7 +257,8 @@ function generateKickoffHint() {
 ✅ 生成 PROJECT_KICKOFF.md
 ✅ 生成 TASK_PLAN.md
 ✅ 生成 PROJECT_PROPOSAL.md
-✅ 等待你的确认后开始执行
+✅ 🆕 自动创建任务到 development/todos/backlog/
+✅ 🆕 刷新任务索引
 
 ═══════════════════════════════════════════════════════════════════════
 
@@ -100,6 +275,20 @@ function main() {
     process.exit(0);
   }
 
+  // 如果已经有任务规划，自动创建任务
+  if (hasTaskPlan()) {
+    console.log('📋 检测到 TASK_PLAN.md，正在创建任务...');
+
+    const createdCount = createTasksFromPlan();
+
+    if (createdCount > 0) {
+      console.log(`✅ 已创建 ${createdCount} 个任务到 backlog/`);
+      refreshTaskIndex();
+    } else {
+      console.log('ℹ️  所有任务已完成或为空');
+    }
+  }
+
   // 生成提示文件
   const hint = generateKickoffHint();
   fs.mkdirSync(path.dirname(HINT_FILE), { recursive: true });

package/template/.claude/hooks/session-restore.cjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * Session Restore Hook - Restore conversation context from file
+ *
+ * Provides context continuity across sessions
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const SESSIONS_DIR = path.join(PROJECT_DIR, '.claude', 'sessions');
+const MEMORY_FILE = path.join(PROJECT_DIR, '.claude', 'MEMORY.md');
+
+/**
+ * Get latest session
+ */
+function getLatestSession() {
+  if (!fs.existsSync(SESSIONS_DIR)) {
+    return null;
+  }
+  
+  const files = fs.readdirSync(SESSIONS_DIR)
+    .filter(f => f.startsWith('session_') && f.endsWith('.md'))
+    .sort()
+    .reverse();
+  
+  if (files.length === 0) {
+    return null;
+  }
+  
+  const latestFile = files[0];
+  const filepath = path.join(SESSIONS_DIR, latestFile);
+  const content = fs.readFileSync(filepath, 'utf-8');
+  
+  return {
+    file: latestFile,
+    path: filepath,
+    content: content
+  };
+}
+
+/**
+ * Get recent memory entries
+ */
+function getRecentMemory(days = 7) {
+  if (!fs.existsSync(MEMORY_FILE)) {
+    return '';
+  }
+  
+  const content = fs.readFileSync(MEMORY_FILE, 'utf-8');
+  const entries = content.split('## ').slice(1, days + 1);
+  
+  return entries.join('## ');
+}
+
+/**
+ * Format context summary for display
+ */
+function formatContextSummary(latestSession, recentMemory) {
+  let summary = '';
+  
+  if (latestSession) {
+    summary += `\n📁 Last Session: ${latestSession.file}\n`;
+    summary += `   Date: ${fs.statSync(latestSession.path).mtime.toLocaleString()}\n`;
+  }
+  
+  const memoryEntries = recentMemory.split('\n').filter(l => l.trim()).length;
+  if (memoryEntries > 0) {
+    summary += `\n💾 Memory Entries: ${memoryEntries}\n`;
+  }
+  
+  return summary;
+}
+
+// Main execution
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  
+  if (args[0] === '--latest') {
+    const session = getLatestSession();
+    if (session) {
+      console.log(session.content);
+    } else {
+      console.log('No sessions found.');
+    }
+  } else if (args[0] === '--memory') {
+    const memory = getRecentMemory(parseInt(args[1]) || 7);
+    console.log('# Recent Memory\n');
+    console.log(memory);
+  } else if (args[0] === '--summary') {
+    const session = getLatestSession();
+    const memory = getRecentMemory();
+    console.log(formatContextSummary(session, memory));
+  } else {
+    console.log('Usage: node session-restore.cjs [--latest|--memory|--summary]');
+  }
+}
+
+exports.getLatestSession = getLatestSession;
+exports.getRecentMemory = getRecentMemory;
+exports.formatContextSummary = formatContextSummary;

package/template/.claude/hooks/session-save.cjs

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+/**
+ * Session Save Hook - Save conversation context to file
+ *
+ * Triggered after each conversation turn
+ * Saves conversation history, context, and state
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const SESSIONS_DIR = path.join(PROJECT_DIR, '.claude', 'sessions');
+const MEMORY_FILE = path.join(PROJECT_DIR, '.claude', 'MEMORY.md');
+
+// Ensure sessions directory exists
+if (!fs.existsSync(SESSIONS_DIR)) {
+  fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+
+/**
+ * Generate session filename
+ */
+function getSessionFilename() {
+  const now = new Date();
+  const date = now.toISOString().split('T')[0];
+  const time = now.toTimeString().split(' ')[0].replace(/:/g, '-');
+  return `session_${date}_${time}.md`;
+}
+
+/**
+ * Save session context
+ */
+function saveSession(context) {
+  const filename = getSessionFilename();
+  const filepath = path.join(SESSIONS_DIR, filename);
+  
+  const content = `# Session - ${new Date().toISOString()}
+
+> Type: ${context.type || 'chat'}
+> Model: ${context.model || 'unknown'}
+> Duration: ${context.duration || 'unknown'}
+
+---
+
+## Summary
+
+${context.summary || 'No summary provided'}
+
+---
+
+## Context
+
+\`\`\`json
+${JSON.stringify(context.metadata || {}, null, 2)}
+\`\`\`
+
+---
+
+## Key Points
+
+${(context.keyPoints || []).map((p, i) => `${i + 1}. ${p}`).join('\n')}
+
+---
+
+## Artifacts
+
+${(context.artifacts || []).map(a => `- ${a}`).join('\n') || 'None'}
+
+---
+
+## Next Steps
+
+${context.nextSteps || 'None'}
+
+---
+
+*Session saved at: ${new Date().toISOString()}*
+`;
+
+  fs.writeFileSync(filepath, content, 'utf-8');
+  
+  // Update sessions index
+  updateSessionsIndex();
+  
+  return filename;
+}
+
+/**
+ * Update sessions index
+ */
+function updateSessionsIndex() {
+  const files = fs.readdirSync(SESSIONS_DIR)
+    .filter(f => f.endsWith('.md'))
+    .sort()
+    .reverse();
+  
+  const indexPath = path.join(SESSIONS_DIR, 'INDEX.md');
+  
+  let content = `# Sessions Index
+
+> Total sessions: ${files.length}
+> Last updated: ${new Date().toISOString()}
+
+---
+
+## Recent Sessions
+
+${files.slice(0, 20).map(f => {
+  const filepath = path.join(SESSIONS_DIR, f);
+  const stat = fs.statSync(filepath);
+  return `- [${f}](${f}) - ${stat.mtime.toISOString()}`;
+}).join('\n')}
+
+---
+`;
+  
+  fs.writeFileSync(indexPath, content, 'utf-8');
+}
+
+/**
+ * Update MEMORY.md with latest context
+ */
+function updateMemory(context) {
+  const timestamp = new Date().toISOString();
+  
+  let content = '';
+  
+  if (fs.existsSync(MEMORY_FILE)) {
+    content = fs.readFileSync(MEMORY_FILE, 'utf-8');
+  }
+  
+  // Check if we need to add a new entry
+  const newEntry = `\n## ${timestamp.split('T')[0]}\n\n${
+    context.summary || context.keyPoints?.join('\n') || 'No details'
+  }\n`;
+  
+  // Keep only last 7 days
+  const entries = content.split('## ').slice(1, 8);
+  content = '# Memory\n\n<!-- Project memory updated by AI -->\n' + 
+    '## ' + entries.join('## ') + newEntry;
+  
+  fs.writeFileSync(MEMORY_FILE, content, 'utf-8');
+}
+
+// Main execution
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  
+  if (args[0] === '--save' && args[1]) {
+    const contextData = JSON.parse(fs.readFileSync(args[1], 'utf-8'));
+    const filename = saveSession(contextData);
+    console.log(`✅ Session saved: ${filename}`);
+    
+    if (contextData.addToMemory !== false) {
+      updateMemory(contextData);
+      console.log(`✅ Memory updated`);
+    }
+  }
+}
+
+exports.saveSession = saveSession;
+exports.updateMemory = updateMemory;
+exports.updateSessionsIndex = updateSessionsIndex;