sumulige-claude 1.0.9 → 1.1.0

package/lib/migrations.js

@@ -0,0 +1,154 @@
+/**
+ * Migrations - Version control for project templates
+ *
+ * 每个迁移函数：
+ * - from: 起始版本
+ * - to: 目标版本
+ * - migrate: 实际迁移逻辑
+ *
+ * 迁移链：v1.0.0 → v1.0.2 → v1.0.10 → ...
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 当前模板版本
+const TEMPLATE_VERSION = '1.0.10';
+
+// 版本文件路径
+const getVersionFile = (projectDir) => path.join(projectDir, '.claude', '.version');
+
+// 读取项目版本
+function getProjectVersion(projectDir) {
+  const versionFile = getVersionFile(projectDir);
+  if (!fs.existsSync(versionFile)) {
+    // 没有 version 文件说明是旧版本项目
+    return '1.0.0';
+  }
+  try {
+    return fs.readFileSync(versionFile, 'utf-8').trim();
+  } catch {
+    return '1.0.0';
+  }
+}
+
+// 写入项目版本
+function setProjectVersion(projectDir, version) {
+  const versionFile = getVersionFile(projectDir);
+  fs.writeFileSync(versionFile, version + '\n');
+}
+
+// 版本比较
+function compareVersions(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    if (parts1[i] < parts2[i]) return -1;
+    if (parts1[i] > parts2[i]) return 1;
+  }
+  return 0;
+}
+
+// 迁移列表
+const migrations = [
+  {
+    from: '1.0.0',
+    to: '1.0.10',
+    description: 'Migrate hooks format from old to new',
+    migrate: (projectDir) => {
+      const settingsFile = path.join(projectDir, '.claude', 'settings.json');
+      if (!fs.existsSync(settingsFile)) return;
+
+      let settings;
+      try {
+        settings = JSON.parse(fs.readFileSync(settingsFile, 'utf-8'));
+      } catch {
+        return; // 无效 JSON，跳过
+      }
+
+      // 检测旧格式
+      const isOldFormat = settings.matcher || (settings.hooks && typeof settings.hooks === 'object');
+      if (!isOldFormat) return;
+
+      // 读取新模板
+      const templateDir = path.join(__dirname, '../template');
+      const templateSettings = path.join(templateDir, '.claude', 'settings.json');
+
+      if (fs.existsSync(templateSettings)) {
+        fs.writeFileSync(settingsFile, fs.readFileSync(templateSettings, 'utf-8'));
+      }
+    }
+  }
+];
+
+/**
+ * 执行迁移
+ * @param {string} projectDir - 项目目录
+ * @param {boolean} silent - 是否静默模式
+ * @returns {object} { success, migrations, currentVersion }
+ */
+function runMigrations(projectDir, silent = false) {
+  const currentVersion = getProjectVersion(projectDir);
+
+  // 已经是最新版本
+  if (compareVersions(currentVersion, TEMPLATE_VERSION) >= 0) {
+    return {
+      success: true,
+      migrations: [],
+      currentVersion,
+      templateVersion: TEMPLATE_VERSION
+    };
+  }
+
+  // 找到需要执行的迁移
+  const pendingMigrations = migrations.filter(m => {
+    const cmp = compareVersions(currentVersion, m.to);
+    return cmp < 0; // 只执行版本高于当前版本的迁移
+  });
+
+  // 按版本顺序执行
+  pendingMigrations.sort((a, b) => compareVersions(a.to, b.to));
+
+  const executed = [];
+
+  for (const migration of pendingMigrations) {
+    try {
+      if (!silent) {
+        console.log(`⬆️  Migrating: ${currentVersion} → ${migration.to}`);
+        console.log(`   ${migration.description}`);
+      }
+      migration.migrate(projectDir);
+      executed.push(migration);
+      setProjectVersion(projectDir, migration.to);
+      if (!silent) {
+        console.log(`   ✅ Done`);
+      }
+    } catch (error) {
+      if (!silent) {
+        console.log(`   ❌ Failed: ${error.message}`);
+      }
+      return {
+        success: false,
+        error: error.message,
+        currentVersion,
+        executed
+      };
+    }
+  }
+
+  return {
+    success: true,
+    migrations: executed,
+    currentVersion: TEMPLATE_VERSION,
+    templateVersion: TEMPLATE_VERSION
+  };
+}
+
+module.exports = {
+  TEMPLATE_VERSION,
+  getProjectVersion,
+  setProjectVersion,
+  compareVersions,
+  runMigrations
+};

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.9",
+  "version": "1.1.0",
   "description": "The Best Agent Harness for Claude Code",
   "main": "cli.js",
   "bin": {
@@ -8,11 +8,17 @@
     "sumulige-claude": "cli.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "test:watch": "jest --watch",
     "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",
@@ -35,7 +41,11 @@
     "node": ">=16.0.0"
   },
   "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/scripts/fix-hooks.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+/**
+ * Fix hooks format from old to new
+ * 旧格式：{"matcher": "...", "hooks": [...]}
+ * 新格式：{"UserPromptSubmit": [{"matcher": {}, "hooks": [...]}], ...}
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+const NEW_FORMAT = {
+  "UserPromptSubmit": [
+    {
+      "matcher": {},
+      "hooks": [
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/project-kickoff.cjs", "timeout": 1000 },
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/rag-skill-loader.cjs", "timeout": 1000 },
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/thinking-silent.cjs", "timeout": 1000 },
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/multi-session.cjs", "timeout": 1000 },
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/todo-manager.cjs", "timeout": 1000 }
+      ]
+    }
+  ],
+  "PreToolUse": [
+    {
+      "matcher": {},
+      "hooks": [
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/thinking-silent.cjs", "timeout": 1000 },
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/multi-session.cjs", "timeout": 1000 },
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/todo-manager.cjs", "timeout": 1000 }
+      ]
+    }
+  ],
+  "PostToolUse": [
+    {
+      "matcher": {},
+      "hooks": [
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/code-formatter.cjs", "timeout": 5000 },
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/verify-work.cjs", "timeout": 1000 },
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/thinking-silent.cjs", "timeout": 1000 },
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/multi-session.cjs", "timeout": 1000 },
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/todo-manager.cjs", "timeout": 1000 }
+      ]
+    }
+  ],
+  "AgentStop": [
+    {
+      "matcher": {},
+      "hooks": [
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/verify-work.cjs", "timeout": 1000 },
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/thinking-silent.cjs", "timeout": 1000 },
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/multi-session.cjs", "timeout": 1000 },
+        { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/todo-manager.cjs", "timeout": 1000 }
+      ]
+    }
+  ]
+};
+
+function fixProject(projectPath) {
+  const settingsFile = path.join(projectPath, '.claude', 'settings.json');
+
+  if (!fs.existsSync(settingsFile)) {
+    console.log(`⚠️  ${projectPath} - no settings.json`);
+    return false;
+  }
+
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsFile, 'utf-8'));
+  } catch (e) {
+    console.log(`❌ ${projectPath} - invalid JSON`);
+    return false;
+  }
+
+  // 检测旧格式
+  const isOldFormat = settings.matcher || (settings.hooks && typeof settings.hooks === 'object');
+
+  if (!isOldFormat) {
+    console.log(`✅ ${projectPath} - already new format`);
+    return false;
+  }
+
+  // 写入新格式
+  fs.writeFileSync(settingsFile, JSON.stringify(NEW_FORMAT, null, 2) + '\n');
+  console.log(`🔧 ${projectPath} - fixed!`);
+  return true;
+}
+
+// CLI
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+  // 当前目录
+  fixProject(process.cwd());
+} else {
+  args.forEach(fixProject);
+}

package/template/.claude/commands/commit-push-pr.md

@@ -22,7 +22,27 @@ Analyze the changes and:
 2. Identify the main purpose of the changes
 3. Check if there are any sensitive files that shouldn't be committed
 
-## Step 3: Stage and Commit
+## Step 3: Code Simplification (Before Commit)
+
+**IMPORTANT**: Before creating the commit, simplify and refine the code changes:
+
+1. Review the recently modified code sections
+2. Apply code simplification focusing on:
+   - Code clarity and consistency
+   - Reducing unnecessary complexity and nesting
+   - Eliminating redundant code and abstractions
+   - Following project standards (if CLAUDE.md exists)
+   - Preserving exact functionality
+3. Use explicit, readable code over overly compact solutions
+
+**Trigger phrases to apply simplification**:
+- "简化此代码" (Simplify this code)
+- "使这更清晰" (Make this clearer)
+- "优化此实现" (Optimize this implementation)
+
+Ask the user: "是否需要简化代码？(Need code simplification?)" - if yes, apply code-simplifier agent before proceeding.
+
+## Step 4: Stage and Commit
 
 If there are unstaged changes that should be included, ask the user first.
 
@@ -36,7 +56,7 @@ Then create a commit with a clear message following this format:
 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
 ```
 
-## Step 4: Push and Create PR
+## Step 5: Push and Create PR
 
 1. Push the changes to remote
 2. Check if there's an open PR for this branch using:
@@ -51,7 +71,7 @@ Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
      - Test plan (checklist)
      - Link to any related issues
 
-## Step 5: Verify
+## Step 6: Verify
 
 After creating the PR, show the PR URL and check CI status using:
 ```bash