sumulige-claude 1.0.11 → 1.1.0

package/lib/utils.js

@@ -8,20 +8,35 @@ const fs = require('fs');
 const path = require('path');
 
 /**
- * Recursively copy directory contents
+ * Copy mode for template deployment
+ */
+const CopyMode = {
+  SAFE: 'safe',        // Skip existing files (no overwrite, no backup)
+  BACKUP: 'backup',     // Backup then overwrite (default)
+  FORCE: 'force'        // Overwrite without backup
+};
+
+/**
+ * Recursively copy directory contents with backup support
  * @param {string} src - Source directory
  * @param {string} dest - Destination directory
- * @param {boolean} overwrite - Whether to overwrite existing files
- * @returns {number} Number of files copied
+ * @param {boolean|string} mode - Copy mode: true/false (legacy) or CopyMode enum
+ * @param {string} backupDir - Backup directory path
+ * @returns {object} Copy result { copied, skipped, backedup }
  */
-exports.copyRecursive = function(src, dest, overwrite = false) {
-  if (!fs.existsSync(src)) return 0;
+exports.copyRecursive = function(src, dest, mode = CopyMode.BACKUP, backupDir = null) {
+  if (!fs.existsSync(src)) return { copied: 0, skipped: 0, backedup: 0 };
+
+  // Legacy support: convert boolean to CopyMode
+  if (typeof mode === 'boolean') {
+    mode = mode ? CopyMode.FORCE : CopyMode.SAFE;
+  }
 
   if (!fs.existsSync(dest)) {
     fs.mkdirSync(dest, { recursive: true });
   }
 
-  let count = 0;
+  const result = { copied: 0, skipped: 0, backedup: 0 };
   const entries = fs.readdirSync(src, { withFileTypes: true });
 
   for (const entry of entries) {
@@ -29,19 +44,89 @@ exports.copyRecursive = function(src, dest, overwrite = false) {
     const destPath = path.join(dest, entry.name);
 
     if (entry.isDirectory()) {
-      count += exports.copyRecursive(srcPath, destPath, overwrite);
-    } else if (overwrite || !fs.existsSync(destPath)) {
-      fs.copyFileSync(srcPath, destPath);
-      // Add execute permission for scripts
-      if (entry.name.endsWith('.sh') || entry.name.endsWith('.cjs')) {
-        fs.chmodSync(destPath, 0o755);
+      const subResult = exports.copyRecursive(
+        srcPath,
+        destPath,
+        mode,
+        backupDir ? path.join(backupDir, entry.name) : null
+      );
+      result.copied += subResult.copied;
+      result.skipped += subResult.skipped;
+      result.backedup += subResult.backedup;
+    } else {
+      const action = copyFile(srcPath, destPath, mode, backupDir);
+      result[action.type === 'copied' ? 'copied' : action.type]++;
+      if (action.type === 'backedup') {
+        result.copied++;
+        result.backedup++;
       }
-      count++;
     }
   }
-  return count;
+  return result;
 };
 
+/**
+ * Copy a single file with backup support
+ * @param {string} srcPath - Source file path
+ * @param {string} destPath - Destination file path
+ * @param {string} mode - Copy mode
+ * @param {string} backupDir - Backup directory path
+ * @returns {object} Action result { type, backupPath }
+ */
+function copyFile(srcPath, destPath, mode, backupDir) {
+  // File doesn't exist - just copy
+  if (!fs.existsSync(destPath)) {
+    fs.copyFileSync(srcPath, destPath);
+    setExecutablePermission(destPath);
+    return { type: 'copied' };
+  }
+
+  // File exists - handle based on mode
+  switch (mode) {
+    case CopyMode.SAFE:
+      // Skip existing files
+      return { type: 'skipped' };
+
+    case CopyMode.FORCE:
+      // Overwrite without backup
+      fs.copyFileSync(srcPath, destPath);
+      setExecutablePermission(destPath);
+      return { type: 'copied' };
+
+    case CopyMode.BACKUP:
+    default:
+      // Backup then overwrite
+      if (backupDir) {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
+        const backupFileName = path.basename(destPath) + '.' + timestamp + '.bak';
+        const backupPath = path.join(backupDir, backupFileName);
+
+        fs.mkdirSync(backupDir, { recursive: true });
+        fs.copyFileSync(destPath, backupPath);
+        setExecutablePermission(backupPath);
+
+        fs.copyFileSync(srcPath, destPath);
+        setExecutablePermission(destPath);
+        return { type: 'backedup', backupPath };
+      } else {
+        // No backup dir, just overwrite
+        fs.copyFileSync(srcPath, destPath);
+        setExecutablePermission(destPath);
+        return { type: 'copied' };
+      }
+  }
+}
+
+/**
+ * Set executable permission for script files
+ * @param {string} filePath - File path
+ */
+function setExecutablePermission(filePath) {
+  if (filePath.endsWith('.sh') || filePath.endsWith('.cjs')) {
+    fs.chmodSync(filePath, 0o755);
+  }
+}
+
 /**
  * Ensure a directory exists
  * @param {string} dir - Directory path
@@ -60,3 +145,6 @@ exports.ensureDir = function(dir) {
 exports.toTitleCase = function(str) {
   return str.replace(/\b\w/g, char => char.toUpperCase());
 };
+
+// Export CopyMode for use in other modules
+exports.CopyMode = CopyMode;

package/lib/version-check.js

@@ -0,0 +1,169 @@
+/**
+ * Version Check - Check for updates from npm registry
+ *
+ * Implements lazy checking with local caching to minimize
+ * network requests and performance impact.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const CONFIG_DIR = path.join(process.env.HOME, '.claude');
+const CHECK_FILE = path.join(CONFIG_DIR, '.last-update-check');
+const ONE_DAY = 24 * 60 * 60 * 1000;
+
+// Current version from package.json
+const CURRENT_VERSION = require('../package.json').version;
+const PACKAGE_NAME = 'sumulige-claude';
+
+/**
+ * Get timestamp of last update check
+ * @returns {number} Timestamp of last check, or 0 if never checked
+ */
+function getLastCheckTime() {
+  try {
+    const content = fs.readFileSync(CHECK_FILE, 'utf-8');
+    return parseInt(content, 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Save timestamp of current update check
+ * @param {number} timestamp - Timestamp to save
+ */
+function saveLastCheckTime(timestamp = Date.now()) {
+  try {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CHECK_FILE, timestamp.toString());
+  } catch {
+    // Ignore errors
+  }
+}
+
+/**
+ * Fetch latest version from npm registry
+ * @returns {Promise<string|null>} Latest version or null if failed
+ */
+function fetchLatestVersion() {
+  return new Promise((resolve) => {
+    const options = {
+      hostname: 'registry.npmjs.org',
+      path: `/${PACKAGE_NAME}`,
+      timeout: 5000, // 5 second timeout
+      headers: {
+        'User-Agent': `${PACKAGE_NAME}/${CURRENT_VERSION}`
+      }
+    };
+
+    const req = https.get(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const pkg = JSON.parse(data);
+          resolve(pkg['dist-tags']?.latest || null);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+    req.setTimeout(5000);
+  });
+}
+
+/**
+ * Check for updates (with caching)
+ * @param {Object} options - Check options
+ * @param {boolean} options.force - Force check even if within cache period
+ * @param {boolean} options.silent - Don't print messages
+ * @returns {Promise<Object>} Check result { current, latest, updateAvailable }
+ */
+async function checkUpdate(options = {}) {
+  const { force = false, silent = false } = options;
+  const now = Date.now();
+  const lastCheck = getLastCheckTime();
+  const shouldCheck = force || (now - lastCheck > ONE_DAY);
+
+  if (!shouldCheck) {
+    return {
+      current: CURRENT_VERSION,
+      latest: null,
+      updateAvailable: false,
+      cached: true
+    };
+  }
+
+  const latest = await fetchLatestVersion();
+  saveLastCheckTime(now);
+
+  // Only show update if remote version is NEWER than current
+  const updateAvailable = latest && compareVersions(latest, CURRENT_VERSION) > 0;
+  const result = {
+    current: CURRENT_VERSION,
+    latest,
+    updateAvailable,
+    cached: false
+  };
+
+  if (!silent && updateAvailable) {
+    console.log('');
+    console.log(`💡 新版本 v${latest} 可用 (当前: v${CURRENT_VERSION})`);
+    console.log(`   运行: npm update -g ${PACKAGE_NAME}`);
+    console.log('');
+  }
+
+  return result;
+}
+
+/**
+ * Get current version
+ * @returns {string} Current version
+ */
+function getCurrentVersion() {
+  return CURRENT_VERSION;
+}
+
+/**
+ * Parse version string to comparable array
+ * @param {string} version - Version string (e.g., "1.2.3")
+ * @returns {number[]} Comparable array [major, minor, patch]
+ */
+function parseVersion(version) {
+  return version.split('.').map(Number).filter(n => !isNaN(n));
+}
+
+/**
+ * Compare two versions
+ * @param {string} v1 - First version
+ * @param {string} v2 - Second version
+ * @returns {number} -1 if v1 < v2, 0 if equal, 1 if v1 > v2
+ */
+function compareVersions(v1, v2) {
+  const parts1 = parseVersion(v1);
+  const parts2 = parseVersion(v2);
+  const maxLen = Math.max(parts1.length, parts2.length);
+
+  for (let i = 0; i < maxLen; i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    if (p1 < p2) return -1;
+    if (p1 > p2) return 1;
+  }
+  return 0;
+}
+
+exports.checkUpdate = checkUpdate;
+exports.getCurrentVersion = getCurrentVersion;
+exports.compareVersions = compareVersions;
+exports.getLastCheckTime = getLastCheckTime;
+exports.saveLastCheckTime = saveLastCheckTime;
+exports.CURRENT_VERSION = CURRENT_VERSION;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sumulige-claude",
-  "version": "1.0.11",
+  "version": "1.1.0",
   "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",
@@ -41,6 +45,7 @@
     "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;