sumulige-claude 1.3.2 → 1.4.0

package/config/version-manifest.json

@@ -0,0 +1,85 @@
+{
+  "$schema": "version-manifest-schema.json",
+  "$comment": "Version compatibility matrix for incremental sync",
+
+  "current": "1.3.3",
+
+  "history": [
+    {
+      "version": "1.3.0",
+      "date": "2025-01-20",
+      "breaking": false,
+      "changes": [
+        { "type": "skill", "action": "merge", "from": ["librarian", "architect", "builder", "reviewer", "conductor"] }
+      ]
+    },
+    {
+      "version": "1.3.1",
+      "date": "2025-01-21",
+      "breaking": false,
+      "changes": [
+        { "type": "command", "action": "add", "name": "audit" },
+        { "type": "command", "action": "add", "name": "handoff" },
+        { "type": "command", "action": "add", "name": "gha" }
+      ]
+    },
+    {
+      "version": "1.3.2",
+      "date": "2025-01-21",
+      "breaking": false,
+      "changes": [
+        { "type": "hook", "action": "add", "name": "memory-loader" },
+        { "type": "hook", "action": "add", "name": "memory-saver" },
+        { "type": "hook", "action": "add", "name": "auto-handoff" }
+      ]
+    },
+    {
+      "version": "1.3.3",
+      "date": "2025-01-22",
+      "breaking": false,
+      "changes": [
+        { "type": "sync", "action": "add", "feature": "--hooks option" }
+      ]
+    },
+    {
+      "version": "1.4.0",
+      "date": "2025-01-22",
+      "breaking": false,
+      "changes": [
+        { "type": "hook", "action": "add", "name": "hook-dispatcher" },
+        { "type": "config", "action": "add", "name": "hook-registry.json" },
+        { "type": "hook", "action": "update", "name": "rag-skill-loader", "feature": "cache" },
+        { "type": "lib", "action": "add", "name": "hooks/lib/fs-utils.cjs" },
+        { "type": "lib", "action": "add", "name": "hooks/lib/cache.cjs" },
+        { "type": "config", "action": "update", "name": "settings.json", "feature": "dispatcher pattern" },
+        { "type": "sync", "action": "add", "feature": "--incremental option" },
+        { "type": "command", "action": "add", "name": "workflow" }
+      ]
+    }
+  ],
+
+  "syncRules": {
+    "hook": {
+      "add": "copy",
+      "update": "copy",
+      "remove": "delete"
+    },
+    "config": {
+      "add": "copy",
+      "update": "merge"
+    },
+    "command": {
+      "add": "copy",
+      "update": "copy"
+    },
+    "skill": {
+      "add": "copy",
+      "update": "copy",
+      "merge": "reorganize"
+    },
+    "lib": {
+      "add": "copy",
+      "update": "copy"
+    }
+  }
+}

package/lib/commands.js

@@ -335,6 +335,52 @@ const commands = {
   // -------------------------------------------------------------------------
   sync: async (...args) => {
     const forceCheckUpdate = args.includes("--check-update");
+    const syncHooks = args.includes("--hooks");
+    const incrementalSync = args.includes("--incremental");
+    const forceSync = args.includes("--force");
+
+    // 增量同步模式
+    if (incrementalSync) {
+      console.log("🔄 Running incremental sync...");
+      console.log("");
+
+      const projectDir = process.cwd();
+      const incrementalLib = require("./incremental-sync");
+      const result = incrementalLib.incrementalSync(projectDir, { force: forceSync });
+
+      if (result.needsFullSync) {
+        console.log("ℹ️  " + result.message);
+        console.log("   Run: smc sync (without --incremental)");
+        return;
+      }
+
+      if (result.hasBreakingChanges) {
+        console.log("⚠️  " + result.message);
+        console.log("");
+        result.changes.forEach((c) => {
+          if (c.breaking) {
+            console.log(`   🔴 v${c.version}: Breaking changes`);
+          }
+        });
+        return;
+      }
+
+      if (!result.success) {
+        console.log("❌ " + result.message);
+        return;
+      }
+
+      console.log(`✅ ${result.message}`);
+      if (result.results) {
+        const applied = result.results.filter((r) => r.result.success && !r.result.skipped);
+        applied.forEach((r) => {
+          console.log(`   ✅ [${r.version}] ${r.change.type}: ${r.change.name || r.change.feature}`);
+        });
+      }
+      console.log("");
+      console.log("✅ Incremental sync complete!");
+      return;
+    }
 
     console.log("🔄 Syncing Sumulige Claude to current project...");
     console.log("");
@@ -387,6 +433,88 @@ const commands = {
       }
     }
 
+    // Sync hooks if --hooks flag is provided
+    if (syncHooks) {
+      const templateHooksDir = path.join(TEMPLATE_DIR, ".claude", "hooks");
+      const projectHooksDir = path.join(projectConfigDir, "hooks");
+      const templateSettingsFile = path.join(
+        TEMPLATE_DIR,
+        ".claude",
+        "settings.json",
+      );
+      const projectSettingsFile = path.join(projectConfigDir, "settings.json");
+
+      if (fs.existsSync(templateHooksDir)) {
+        ensureDir(projectHooksDir);
+
+        // Sync hook files (only add new ones, don't overwrite)
+        const hookFiles = fs
+          .readdirSync(templateHooksDir)
+          .filter((f) => f.endsWith(".cjs"));
+        let syncedCount = 0;
+
+        hookFiles.forEach((hookFile) => {
+          const src = path.join(templateHooksDir, hookFile);
+          const dest = path.join(projectHooksDir, hookFile);
+
+          if (!fs.existsSync(dest)) {
+            fs.copyFileSync(src, dest);
+            setExecutablePermission(dest);
+            syncedCount++;
+            console.log(`   ✅ Added ${hookFile}`);
+          }
+        });
+
+        if (syncedCount > 0) {
+          console.log(`✅ Synced ${syncedCount} new hook(s)`);
+        } else {
+          console.log("✅ Hooks up to date");
+        }
+      }
+
+      // Sync settings.json (merge new lifecycle hooks)
+      if (
+        fs.existsSync(templateSettingsFile) &&
+        fs.existsSync(projectSettingsFile)
+      ) {
+        try {
+          const templateSettings = JSON.parse(
+            fs.readFileSync(templateSettingsFile, "utf-8"),
+          );
+          const projectSettings = JSON.parse(
+            fs.readFileSync(projectSettingsFile, "utf-8"),
+          );
+
+          // Merge new lifecycle hooks
+          const lifecycleHooks = [
+            "SessionStart",
+            "SessionEnd",
+            "PreCompact",
+            "env",
+          ];
+          let updated = false;
+
+          lifecycleHooks.forEach((hook) => {
+            if (templateSettings[hook] && !projectSettings[hook]) {
+              projectSettings[hook] = templateSettings[hook];
+              updated = true;
+              console.log(`   ✅ Added ${hook} hook`);
+            }
+          });
+
+          if (updated) {
+            fs.writeFileSync(
+              projectSettingsFile,
+              JSON.stringify(projectSettings, null, 2),
+            );
+            console.log("✅ Updated settings.json");
+          }
+        } catch (e) {
+          console.log("⚠️  Failed to merge settings.json");
+        }
+      }
+    }
+
     // Sync todos directory structure
     const todosTemplateDir = path.join(TEMPLATE_DIR, "development", "todos");
     const todosProjectDir = path.join(projectDir, "development", "todos");
@@ -403,6 +531,17 @@ const commands = {
       console.log("⚠️  Failed to sync skills");
     }
 
+    // Update project version after full sync
+    try {
+      const versionManifest = require("./version-manifest");
+      const currentVersion = versionManifest.getCurrentVersion();
+      if (currentVersion) {
+        versionManifest.setProjectVersion(projectDir, currentVersion);
+      }
+    } catch (e) {
+      // Version manifest not available, ignore
+    }
+
     console.log("");
     console.log("✅ Sync complete!");
 

package/lib/incremental-sync.js

@@ -0,0 +1,274 @@
+/**
+ * Incremental Sync Manager
+ *
+ * 增量同步功能，只同步变更的文件
+ */
+
+const fs = require('fs');
+const path = require('path');
+const versionManifest = require('./version-manifest');
+
+const TEMPLATE_DIR = path.join(__dirname, '../template');
+
+/**
+ * 复制文件
+ */
+function copyFile(src, dest) {
+  const dir = path.dirname(dest);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.copyFileSync(src, dest);
+}
+
+/**
+ * 合并 JSON 配置
+ */
+function mergeJsonConfig(src, dest) {
+  let existing = {};
+  if (fs.existsSync(dest)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(dest, 'utf-8'));
+    } catch (e) {
+      existing = {};
+    }
+  }
+
+  const newConfig = JSON.parse(fs.readFileSync(src, 'utf-8'));
+
+  // 深度合并
+  const merged = deepMerge(existing, newConfig);
+
+  const dir = path.dirname(dest);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(dest, JSON.stringify(merged, null, 2));
+}
+
+/**
+ * 深度合并对象
+ */
+function deepMerge(target, source) {
+  const result = { ...target };
+
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = deepMerge(result[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 应用单个变更
+ */
+function applyChange(change, projectDir, rules) {
+  const rule = rules[change.type];
+  if (!rule) return { success: false, reason: 'Unknown change type' };
+
+  const action = rule[change.action];
+  if (!action) return { success: false, reason: 'Unknown action' };
+
+  try {
+    switch (change.type) {
+      case 'hook':
+        return applyHookChange(change, projectDir, action);
+      case 'config':
+        return applyConfigChange(change, projectDir, action);
+      case 'command':
+        return applyCommandChange(change, projectDir, action);
+      case 'lib':
+        return applyLibChange(change, projectDir, action);
+      case 'skill':
+        return applySkillChange(change, projectDir, action);
+      default:
+        return { success: true, skipped: true };
+    }
+  } catch (e) {
+    return { success: false, reason: e.message };
+  }
+}
+
+/**
+ * 应用 hook 变更
+ */
+function applyHookChange(change, projectDir, action) {
+  const hookName = change.name;
+  const src = path.join(TEMPLATE_DIR, '.claude/hooks', `${hookName}.cjs`);
+  const dest = path.join(projectDir, '.claude/hooks', `${hookName}.cjs`);
+
+  if (action === 'copy') {
+    if (fs.existsSync(src)) {
+      copyFile(src, dest);
+      return { success: true, action: 'copied', file: dest };
+    }
+    return { success: false, reason: 'Source file not found' };
+  }
+
+  if (action === 'delete') {
+    if (fs.existsSync(dest)) {
+      fs.unlinkSync(dest);
+      return { success: true, action: 'deleted', file: dest };
+    }
+    return { success: true, skipped: true };
+  }
+
+  return { success: true, skipped: true };
+}
+
+/**
+ * 应用配置变更
+ */
+function applyConfigChange(change, projectDir, action) {
+  const configName = change.name;
+  let src, dest;
+
+  if (configName === 'settings.json') {
+    src = path.join(TEMPLATE_DIR, '.claude/settings.json');
+    dest = path.join(projectDir, '.claude/settings.json');
+  } else if (configName === 'hook-registry.json') {
+    src = path.join(TEMPLATE_DIR, '.claude/hooks/hook-registry.json');
+    dest = path.join(projectDir, '.claude/hooks/hook-registry.json');
+  } else {
+    src = path.join(TEMPLATE_DIR, '.claude', configName);
+    dest = path.join(projectDir, '.claude', configName);
+  }
+
+  if (action === 'copy') {
+    if (fs.existsSync(src)) {
+      copyFile(src, dest);
+      return { success: true, action: 'copied', file: dest };
+    }
+    return { success: false, reason: 'Source file not found' };
+  }
+
+  if (action === 'merge') {
+    if (fs.existsSync(src)) {
+      mergeJsonConfig(src, dest);
+      return { success: true, action: 'merged', file: dest };
+    }
+    return { success: false, reason: 'Source file not found' };
+  }
+
+  return { success: true, skipped: true };
+}
+
+/**
+ * 应用命令变更
+ */
+function applyCommandChange(change, projectDir, action) {
+  const commandName = change.name;
+  const src = path.join(TEMPLATE_DIR, '.claude/commands', `${commandName}.md`);
+  const dest = path.join(projectDir, '.claude/commands', `${commandName}.md`);
+
+  if (action === 'copy') {
+    if (fs.existsSync(src)) {
+      copyFile(src, dest);
+      return { success: true, action: 'copied', file: dest };
+    }
+    return { success: false, reason: 'Source file not found' };
+  }
+
+  return { success: true, skipped: true };
+}
+
+/**
+ * 应用库文件变更
+ */
+function applyLibChange(change, projectDir, action) {
+  const libPath = change.name;
+  const src = path.join(TEMPLATE_DIR, '.claude', libPath);
+  const dest = path.join(projectDir, '.claude', libPath);
+
+  if (action === 'copy') {
+    if (fs.existsSync(src)) {
+      copyFile(src, dest);
+      return { success: true, action: 'copied', file: dest };
+    }
+    return { success: false, reason: 'Source file not found' };
+  }
+
+  return { success: true, skipped: true };
+}
+
+/**
+ * 应用技能变更
+ */
+function applySkillChange(change, projectDir, action) {
+  // 技能同步由现有的 sync 命令处理
+  return { success: true, skipped: true, reason: 'Skills handled by full sync' };
+}
+
+/**
+ * 执行增量同步
+ */
+function incrementalSync(projectDir, options = {}) {
+  const summary = versionManifest.getUpdateSummary(projectDir);
+
+  if (!summary.needsUpdate) {
+    return {
+      success: true,
+      message: 'Already up to date',
+      changes: []
+    };
+  }
+
+  if (summary.isNewInstall) {
+    return {
+      success: false,
+      message: 'New installation detected. Please run full sync first.',
+      needsFullSync: true
+    };
+  }
+
+  if (summary.hasBreakingChanges && !options.force) {
+    return {
+      success: false,
+      message: 'Breaking changes detected. Use --force to continue.',
+      hasBreakingChanges: true,
+      changes: summary.changes
+    };
+  }
+
+  const rules = versionManifest.getSyncRules();
+  const results = [];
+
+  for (const versionChange of summary.changes) {
+    for (const change of versionChange.changes) {
+      const result = applyChange(change, projectDir, rules);
+      results.push({
+        version: versionChange.version,
+        change,
+        result
+      });
+    }
+  }
+
+  // 更新项目版本
+  versionManifest.setProjectVersion(projectDir, summary.toVersion);
+
+  return {
+    success: true,
+    message: `Updated from ${summary.fromVersion} to ${summary.toVersion}`,
+    fromVersion: summary.fromVersion,
+    toVersion: summary.toVersion,
+    results: results
+  };
+}
+
+/**
+ * 检查更新
+ */
+function checkForUpdates(projectDir) {
+  return versionManifest.getUpdateSummary(projectDir);
+}
+
+module.exports = {
+  incrementalSync,
+  checkForUpdates,
+  applyChange
+};

package/lib/version-manifest.js

@@ -0,0 +1,171 @@
+/**
+ * Version Manifest Manager
+ *
+ * 管理版本清单，支持增量同步
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const MANIFEST_FILE = path.join(__dirname, '../config/version-manifest.json');
+const VERSION_FILE_NAME = '.sumulige-claude-version';
+
+/**
+ * 加载版本清单
+ */
+function loadManifest() {
+  if (!fs.existsSync(MANIFEST_FILE)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(MANIFEST_FILE, 'utf-8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * 获取项目当前版本
+ */
+function getProjectVersion(projectDir) {
+  const versionFile = path.join(projectDir, '.claude', VERSION_FILE_NAME);
+  if (!fs.existsSync(versionFile)) {
+    return null;
+  }
+  try {
+    return fs.readFileSync(versionFile, 'utf-8').trim();
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * 设置项目版本
+ */
+function setProjectVersion(projectDir, version) {
+  const versionFile = path.join(projectDir, '.claude', VERSION_FILE_NAME);
+  const dir = path.dirname(versionFile);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(versionFile, version);
+}
+
+/**
+ * 比较版本号
+ * @returns -1 if a < b, 0 if a == b, 1 if a > b
+ */
+function compareVersions(a, b) {
+  const partsA = a.split('.').map(Number);
+  const partsB = b.split('.').map(Number);
+
+  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA < numB) return -1;
+    if (numA > numB) return 1;
+  }
+  return 0;
+}
+
+/**
+ * 获取版本之间的变更
+ */
+function getChangesSince(fromVersion, toVersion = null) {
+  const manifest = loadManifest();
+  if (!manifest) return [];
+
+  const targetVersion = toVersion || manifest.current;
+  const changes = [];
+
+  for (const entry of manifest.history) {
+    if (compareVersions(entry.version, fromVersion) > 0 &&
+        compareVersions(entry.version, targetVersion) <= 0) {
+      changes.push({
+        version: entry.version,
+        date: entry.date,
+        breaking: entry.breaking,
+        changes: entry.changes
+      });
+    }
+  }
+
+  return changes.sort((a, b) => compareVersions(a.version, b.version));
+}
+
+/**
+ * 检测是否有 breaking changes
+ */
+function hasBreakingChanges(fromVersion, toVersion = null) {
+  const changes = getChangesSince(fromVersion, toVersion);
+  return changes.some(c => c.breaking);
+}
+
+/**
+ * 获取当前版本
+ */
+function getCurrentVersion() {
+  const manifest = loadManifest();
+  return manifest ? manifest.current : null;
+}
+
+/**
+ * 获取同步规则
+ */
+function getSyncRules() {
+  const manifest = loadManifest();
+  return manifest ? manifest.syncRules : null;
+}
+
+/**
+ * 检查是否需要更新
+ */
+function needsUpdate(projectDir) {
+  const projectVersion = getProjectVersion(projectDir);
+  if (!projectVersion) return true;
+
+  const currentVersion = getCurrentVersion();
+  if (!currentVersion) return false;
+
+  return compareVersions(projectVersion, currentVersion) < 0;
+}
+
+/**
+ * 获取更新摘要
+ */
+function getUpdateSummary(projectDir) {
+  const projectVersion = getProjectVersion(projectDir);
+  if (!projectVersion) {
+    return {
+      needsUpdate: true,
+      isNewInstall: true,
+      changes: []
+    };
+  }
+
+  const currentVersion = getCurrentVersion();
+  const changes = getChangesSince(projectVersion);
+  const hasBreaking = changes.some(c => c.breaking);
+
+  return {
+    needsUpdate: changes.length > 0,
+    isNewInstall: false,
+    fromVersion: projectVersion,
+    toVersion: currentVersion,
+    hasBreakingChanges: hasBreaking,
+    changes: changes
+  };
+}
+
+module.exports = {
+  loadManifest,
+  getProjectVersion,
+  setProjectVersion,
+  compareVersions,
+  getChangesSince,
+  hasBreakingChanges,
+  getCurrentVersion,
+  getSyncRules,
+  needsUpdate,
+  getUpdateSummary
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sumulige-claude",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "description": "The Best Agent Harness for Claude Code",
   "main": "cli.js",
   "bin": {