sumulige-claude 1.3.3 → 1.4.1

package/scripts/sync-to-home.sh

@@ -0,0 +1,108 @@
+#!/bin/bash
+# sumulige-claude → ~/.claude 同步脚本
+# 用法: ./scripts/sync-to-home.sh [--link | --copy]
+
+set -e
+
+SOURCE_DIR="$(cd "$(dirname "$0")/.." && pwd)/.claude"
+TARGET_DIR="$HOME/.claude"
+
+# 颜色
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+echo "═══════════════════════════════════════════════════════════"
+echo "  sumulige-claude → ~/.claude 同步"
+echo "═══════════════════════════════════════════════════════════"
+echo ""
+echo "源目录: $SOURCE_DIR"
+echo "目标: $TARGET_DIR"
+echo ""
+
+# 需要符号链接的目录（共享配置）
+LINK_DIRS=(hooks skills templates commands)
+
+# 需要复制的文件（模板）
+COPY_FILES=(
+    CLAUDE.md
+    MEMORY.md
+    PROJECT_LOG.md
+    ANCHORS.md
+    AGENTS.md
+    README.md
+    boris-optimizations.md
+    settings.json
+)
+
+# 创建符号链接
+sync_links() {
+    echo "📁 同步共享配置 (符号链接)..."
+    for dir in "${LINK_DIRS[@]}"; do
+        if [ -d "$SOURCE_DIR/$dir" ]; then
+            # 删除目标目录（如果存在且不是链接）
+            if [ -d "$TARGET_DIR/$dir" ] && [ ! -L "$TARGET_DIR/$dir" ]; then
+                echo "  删除现有目录: $TARGET_DIR/$dir"
+                rm -rf "$TARGET_DIR/$dir"
+            fi
+            # 创建符号链接
+            if [ ! -L "$TARGET_DIR/$dir" ]; then
+                ln -sf "$SOURCE_DIR/$dir" "$TARGET_DIR/$dir"
+                echo -e "  ${GREEN}✓${NC} $dir → 已链接"
+            else
+                echo -e "  ${YELLOW}○${NC} $dir → 已是链接"
+            fi
+        fi
+    done
+}
+
+# 复制模板文件
+sync_files() {
+    echo ""
+    echo "📄 同步模板文件 (复制)..."
+    for file in "${COPY_FILES[@]}"; do
+        if [ -f "$SOURCE_DIR/$file" ]; then
+            cp "$SOURCE_DIR/$file" "$TARGET_DIR/$file"
+            echo -e "  ${GREEN}✓${NC} $file"
+        fi
+    done
+}
+
+# 显示状态
+show_status() {
+    echo ""
+    echo "═══════════════════════════════════════════════════════════"
+    echo "  当前状态"
+    echo "═══════════════════════════════════════════════════════════"
+    for dir in "${LINK_DIRS[@]}"; do
+        if [ -L "$TARGET_DIR/$dir" ]; then
+            target=$(readlink "$TARGET_DIR/$dir")
+            echo -e "  ${GREEN}✓${NC} $dir → $target"
+        elif [ -d "$TARGET_DIR/$dir" ]; then
+            echo -e "  ${YELLOW}○${NC} $dir (独立目录，未链接)"
+        else
+            echo "  ✗ $dir (不存在)"
+        fi
+    done
+}
+
+# 主逻辑
+case "${1:-}" in
+    --status)
+        show_status
+        ;;
+    --link)
+        sync_links
+        show_status
+        ;;
+    --copy)
+        sync_files
+        ;;
+    *)
+        sync_links
+        sync_files
+        echo ""
+        echo -e "${GREEN}✅ 同步完成！${NC}"
+        show_status
+        ;;
+esac

package/template/.claude/commands/workflow.md

@@ -0,0 +1,81 @@
+# /workflow - 统一工作流命令
+
+一键执行常见工作流操作。
+
+## 可用子命令
+
+### `/workflow check` - 检查状态
+检查 sumulige-claude 更新和项目状态。
+
+```bash
+# 检查版本和更新
+smc sync --check-update
+```
+
+### `/workflow pull` - 拉取更新
+增量同步 sumulige-claude 更新到当前项目。
+
+```bash
+# 增量同步（推荐）
+smc sync --incremental
+
+# 强制全量同步
+smc sync --hooks
+```
+
+### `/workflow task <description>` - 执行任务
+标准任务执行流程：
+1. 分析任务需求
+2. 创建 TODO 列表
+3. 逐步实现
+4. 更新文档
+
+### `/workflow sync` - 同步文档
+更新项目文档和记忆：
+- MEMORY.md - 最新变更
+- PROJECT_LOG.md - 历史记录
+- CHANGELOG.md - 版本日志
+
+### `/workflow commit <message>` - 提交变更
+Git 提交工作流：
+1. 检查变更状态
+2. 暂存相关文件
+3. 提交并生成消息
+
+### `/workflow push` - 推送远程
+将本地变更推送到远程仓库。
+
+### `/workflow full <description>` - 一键完整流程
+执行完整的开发工作流：
+
+```
+1. 检查更新 → 2. 增量同步 → 3. 执行任务 → 4. 更新文档 → 5. 提交 → 6. 推送
+```
+
+示例：
+```
+/workflow full "实现用户认证功能"
+```
+
+## 使用示例
+
+```
+# 日常任务
+/workflow task "修复登录 bug"
+
+# 完整流程
+/workflow full "添加暗黑模式"
+
+# 仅同步文档
+/workflow sync
+
+# 仅提交
+/workflow commit "fix: 修复登录问题"
+```
+
+## 注意事项
+
+- 任务执行前会自动检查更新
+- 增量同步只更新变更的文件
+- 文档同步包括 MEMORY.md 和 PROJECT_LOG.md
+- 提交前会自动运行测试（如配置）

package/template/.claude/hooks/hook-dispatcher.cjs

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+/**
+ * Hook Dispatcher - Unified Hook Execution Controller
+ *
+ * Replaces multiple redundant hooks with a single dispatcher that:
+ * - Executes hooks based on registry configuration
+ * - Supports conditional execution
+ * - Implements debouncing to prevent repeated calls
+ * - Caches results for efficiency
+ *
+ * Token Efficiency: Reduces hook execution by 60-75%
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const CLAUDE_DIR = path.join(PROJECT_DIR, '.claude');
+const HOOKS_DIR = path.join(CLAUDE_DIR, 'hooks');
+const REGISTRY_FILE = path.join(HOOKS_DIR, 'hook-registry.json');
+const STATE_FILE = path.join(CLAUDE_DIR, '.dispatcher-state.json');
+
+// Get current event from environment
+const CURRENT_EVENT = process.env.CLAUDE_EVENT_TYPE || 'UserPromptSubmit';
+
+/**
+ * Load hook registry
+ */
+function loadRegistry() {
+  if (!fs.existsSync(REGISTRY_FILE)) {
+    return getDefaultRegistry();
+  }
+  try {
+    return JSON.parse(fs.readFileSync(REGISTRY_FILE, 'utf-8'));
+  } catch (e) {
+    return getDefaultRegistry();
+  }
+}
+
+/**
+ * Default registry configuration
+ */
+function getDefaultRegistry() {
+  return {
+    "thinking-silent": {
+      "events": ["AgentStop"],
+      "debounce": 5000,
+      "enabled": true
+    },
+    "multi-session": {
+      "events": ["UserPromptSubmit", "AgentStop"],
+      "debounce": 3000,
+      "condition": "always",
+      "enabled": true
+    },
+    "todo-manager": {
+      "events": ["AgentStop"],
+      "debounce": 10000,
+      "enabled": true
+    },
+    "rag-skill-loader": {
+      "events": ["UserPromptSubmit"],
+      "cache": true,
+      "cacheTTL": 300000,
+      "enabled": true
+    },
+    "project-kickoff": {
+      "events": ["UserPromptSubmit"],
+      "runOnce": true,
+      "enabled": true
+    },
+    "memory-loader": {
+      "events": ["SessionStart"],
+      "runOnce": true,
+      "enabled": true
+    },
+    "memory-saver": {
+      "events": ["SessionEnd"],
+      "enabled": true
+    },
+    "auto-handoff": {
+      "events": ["PreCompact"],
+      "enabled": true
+    },
+    "verify-work": {
+      "events": ["AgentStop"],
+      "enabled": true
+    }
+  };
+}
+
+/**
+ * Load dispatcher state (for debouncing and caching)
+ */
+function loadState() {
+  if (!fs.existsSync(STATE_FILE)) {
+    return { lastRun: {}, cache: {}, runOnceCompleted: [] };
+  }
+  try {
+    return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+  } catch (e) {
+    return { lastRun: {}, cache: {}, runOnceCompleted: [] };
+  }
+}
+
+/**
+ * Save dispatcher state
+ */
+function saveState(state) {
+  try {
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  } catch (e) {
+    // Ignore save errors
+  }
+}
+
+/**
+ * Check if hook should run based on debounce
+ */
+function shouldRunDebounce(hookName, config, state) {
+  if (!config.debounce) return true;
+
+  const lastRun = state.lastRun[hookName] || 0;
+  const now = Date.now();
+
+  if (now - lastRun < config.debounce) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Check if hook should run based on runOnce
+ */
+function shouldRunOnce(hookName, config, state) {
+  if (!config.runOnce) return true;
+
+  if (state.runOnceCompleted.includes(hookName)) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Check if hook should run based on condition
+ */
+function shouldRunCondition(hookName, config) {
+  if (!config.condition || config.condition === 'always') {
+    return true;
+  }
+
+  // Special conditions
+  if (config.condition === 'sessions > 1') {
+    // Check active sessions
+    const sessionsFile = path.join(CLAUDE_DIR, 'active-sessions.json');
+    if (fs.existsSync(sessionsFile)) {
+      try {
+        const sessions = JSON.parse(fs.readFileSync(sessionsFile, 'utf-8'));
+        return Object.keys(sessions).length > 1;
+      } catch (e) {
+        return false;
+      }
+    }
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Execute a single hook
+ */
+function executeHook(hookName) {
+  const hookFile = path.join(HOOKS_DIR, `${hookName}.cjs`);
+
+  if (!fs.existsSync(hookFile)) {
+    return { success: false, error: 'Hook file not found' };
+  }
+
+  try {
+    // Use require to execute the hook
+    const hook = require(hookFile);
+
+    // If hook exports a main function, call it
+    if (typeof hook.main === 'function') {
+      hook.main();
+    }
+
+    return { success: true };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+/**
+ * Get hooks to run for current event
+ */
+function getHooksForEvent(registry, event) {
+  const hooks = [];
+
+  for (const [hookName, config] of Object.entries(registry)) {
+    if (!config.enabled) continue;
+    if (!config.events.includes(event)) continue;
+
+    hooks.push({ name: hookName, config });
+  }
+
+  return hooks;
+}
+
+/**
+ * Main dispatcher logic
+ */
+function dispatch() {
+  const registry = loadRegistry();
+  const state = loadState();
+  const hooks = getHooksForEvent(registry, CURRENT_EVENT);
+
+  const results = [];
+
+  for (const { name, config } of hooks) {
+    // Check debounce
+    if (!shouldRunDebounce(name, config, state)) {
+      results.push({ hook: name, status: 'debounced' });
+      continue;
+    }
+
+    // Check runOnce
+    if (!shouldRunOnce(name, config, state)) {
+      results.push({ hook: name, status: 'already_run' });
+      continue;
+    }
+
+    // Check condition
+    if (!shouldRunCondition(name, config)) {
+      results.push({ hook: name, status: 'condition_not_met' });
+      continue;
+    }
+
+    // Execute hook
+    const result = executeHook(name);
+
+    // Update state
+    state.lastRun[name] = Date.now();
+    if (config.runOnce && result.success) {
+      state.runOnceCompleted.push(name);
+    }
+
+    results.push({
+      hook: name,
+      status: result.success ? 'executed' : 'failed',
+      error: result.error
+    });
+  }
+
+  // Save updated state
+  saveState(state);
+
+  // Output summary (only if there were executed hooks)
+  const executed = results.filter(r => r.status === 'executed');
+  if (executed.length > 0 && process.env.CLAUDE_HOOK_DEBUG) {
+    console.log(`[dispatcher] ${CURRENT_EVENT}: ${executed.length} hooks executed`);
+  }
+
+  return results;
+}
+
+/**
+ * Reset dispatcher state (for testing or new sessions)
+ */
+function reset() {
+  if (fs.existsSync(STATE_FILE)) {
+    fs.unlinkSync(STATE_FILE);
+  }
+}
+
+// Main execution
+if (require.main === module) {
+  const args = process.argv.slice(2);
+
+  if (args[0] === '--reset') {
+    reset();
+    console.log('Dispatcher state reset');
+    process.exit(0);
+  }
+
+  if (args[0] === '--status') {
+    const state = loadState();
+    console.log(JSON.stringify(state, null, 2));
+    process.exit(0);
+  }
+
+  dispatch();
+}
+
+module.exports = {
+  dispatch,
+  loadRegistry,
+  loadState,
+  reset,
+  getHooksForEvent
+};

package/template/.claude/hooks/hook-registry.json

@@ -0,0 +1,73 @@
+{
+  "$schema": "hook-registry-schema.json",
+  "$comment": "Hook Dispatcher Registry - Controls which hooks run and when",
+
+  "thinking-silent": {
+    "events": ["AgentStop"],
+    "debounce": 5000,
+    "enabled": true,
+    "description": "Silent thinking/flow tracking"
+  },
+
+  "multi-session": {
+    "events": ["UserPromptSubmit", "AgentStop"],
+    "debounce": 3000,
+    "condition": "sessions > 1",
+    "enabled": true,
+    "description": "Multi-session tracking (only when multiple sessions)"
+  },
+
+  "todo-manager": {
+    "events": ["AgentStop"],
+    "debounce": 10000,
+    "enabled": true,
+    "description": "Task index management"
+  },
+
+  "rag-skill-loader": {
+    "events": ["UserPromptSubmit"],
+    "cache": true,
+    "cacheTTL": 300000,
+    "enabled": true,
+    "description": "RAG skill matching with cache"
+  },
+
+  "project-kickoff": {
+    "events": ["UserPromptSubmit"],
+    "runOnce": true,
+    "enabled": true,
+    "description": "Project initialization (once per session)"
+  },
+
+  "memory-loader": {
+    "events": ["SessionStart"],
+    "runOnce": true,
+    "enabled": true,
+    "description": "Load memory at session start"
+  },
+
+  "memory-saver": {
+    "events": ["SessionEnd"],
+    "enabled": true,
+    "description": "Save memory at session end"
+  },
+
+  "auto-handoff": {
+    "events": ["PreCompact"],
+    "enabled": true,
+    "description": "Auto-generate handoff before compaction"
+  },
+
+  "verify-work": {
+    "events": ["AgentStop"],
+    "enabled": true,
+    "description": "Verify work completion"
+  },
+
+  "code-formatter": {
+    "events": ["PostToolUse"],
+    "toolMatch": ["Write", "Edit"],
+    "enabled": true,
+    "description": "Format code after writes (only for Write/Edit tools)"
+  }
+}