sumulige-claude 1.3.2 → 1.4.0

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)"
+  }
+}

package/template/.claude/hooks/lib/cache.cjs

@@ -0,0 +1,161 @@
+/**
+ * Hooks Shared Library - Cache Utilities
+ *
+ * 统一的缓存管理，支持内存和文件缓存
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 内存缓存类
+ */
+class MemoryCache {
+  constructor(defaultTTL = 60000) {
+    this.cache = new Map();
+    this.defaultTTL = defaultTTL;
+  }
+
+  get(key) {
+    const item = this.cache.get(key);
+    if (!item) return null;
+
+    if (Date.now() > item.expiry) {
+      this.cache.delete(key);
+      return null;
+    }
+
+    return item.value;
+  }
+
+  set(key, value, ttl = this.defaultTTL) {
+    this.cache.set(key, {
+      value,
+      expiry: Date.now() + ttl
+    });
+  }
+
+  delete(key) {
+    this.cache.delete(key);
+  }
+
+  clear() {
+    this.cache.clear();
+  }
+
+  cleanup() {
+    const now = Date.now();
+    for (const [key, item] of this.cache.entries()) {
+      if (now > item.expiry) {
+        this.cache.delete(key);
+      }
+    }
+  }
+}
+
+/**
+ * 文件缓存类
+ */
+class FileCache {
+  constructor(cacheFile, defaultTTL = 300000) {
+    this.cacheFile = cacheFile;
+    this.defaultTTL = defaultTTL;
+    this.cache = null;
+  }
+
+  load() {
+    if (this.cache !== null) return;
+
+    if (!fs.existsSync(this.cacheFile)) {
+      this.cache = {};
+      return;
+    }
+
+    try {
+      this.cache = JSON.parse(fs.readFileSync(this.cacheFile, 'utf-8'));
+    } catch (e) {
+      this.cache = {};
+    }
+  }
+
+  save() {
+    try {
+      const dir = path.dirname(this.cacheFile);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.cacheFile, JSON.stringify(this.cache, null, 2));
+    } catch (e) {
+      // 忽略保存错误
+    }
+  }
+
+  get(key) {
+    this.load();
+    const item = this.cache[key];
+    if (!item) return null;
+
+    if (Date.now() > item.expiry) {
+      delete this.cache[key];
+      return null;
+    }
+
+    return item.value;
+  }
+
+  set(key, value, ttl = this.defaultTTL) {
+    this.load();
+    this.cache[key] = {
+      value,
+      expiry: Date.now() + ttl
+    };
+    this.save();
+  }
+
+  delete(key) {
+    this.load();
+    delete this.cache[key];
+    this.save();
+  }
+
+  clear() {
+    this.cache = {};
+    this.save();
+  }
+
+  cleanup() {
+    this.load();
+    const now = Date.now();
+    let changed = false;
+
+    for (const key of Object.keys(this.cache)) {
+      if (now > this.cache[key].expiry) {
+        delete this.cache[key];
+        changed = true;
+      }
+    }
+
+    if (changed) {
+      this.save();
+    }
+  }
+}
+
+/**
+ * 简单哈希函数
+ */
+function hashString(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash = hash & hash;
+  }
+  return hash.toString(16);
+}
+
+module.exports = {
+  MemoryCache,
+  FileCache,
+  hashString
+};

package/template/.claude/hooks/lib/fs-utils.cjs

@@ -0,0 +1,133 @@
+/**
+ * Hooks Shared Library - File System Utilities
+ *
+ * 带缓存的文件操作，减少重复读写
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 内存缓存
+const fileCache = new Map();
+const DEFAULT_TTL = 60000; // 1分钟
+
+/**
+ * 带缓存的 JSON 文件读取
+ */
+function readJsonCached(filePath, ttl = DEFAULT_TTL) {
+  const cached = fileCache.get(filePath);
+  const now = Date.now();
+
+  if (cached && now - cached.time < ttl) {
+    return cached.data;
+  }
+
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    fileCache.set(filePath, { data, time: now });
+    return data;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * 写入 JSON 文件并更新缓存
+ */
+function writeJsonCached(filePath, data) {
+  try {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    fileCache.set(filePath, { data, time: Date.now() });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * 带缓存的文本文件读取
+ */
+function readTextCached(filePath, ttl = DEFAULT_TTL) {
+  const cached = fileCache.get(filePath);
+  const now = Date.now();
+
+  if (cached && now - cached.time < ttl) {
+    return cached.data;
+  }
+
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    const data = fs.readFileSync(filePath, 'utf-8');
+    fileCache.set(filePath, { data, time: now });
+    return data;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * 清除缓存
+ */
+function clearCache(filePath = null) {
+  if (filePath) {
+    fileCache.delete(filePath);
+  } else {
+    fileCache.clear();
+  }
+}
+
+/**
+ * 确保目录存在
+ */
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+/**
+ * 安全文件操作 - 写入
+ */
+function safeWriteFile(filePath, content) {
+  try {
+    ensureDir(path.dirname(filePath));
+    fs.writeFileSync(filePath, content);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * 安全文件操作 - 追加
+ */
+function safeAppendFile(filePath, content) {
+  try {
+    ensureDir(path.dirname(filePath));
+    fs.appendFileSync(filePath, content);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+module.exports = {
+  readJsonCached,
+  writeJsonCached,
+  readTextCached,
+  clearCache,
+  ensureDir,
+  safeWriteFile,
+  safeAppendFile
+};