sumulige-claude 1.3.2 → 1.4.0

package/template/.claude/hooks/memory-loader.cjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+/**
+ * Memory Loader Hook - SessionStart Auto-Load System
+ *
+ * Claude Official Hook: SessionStart
+ * Triggered: Once at the beginning of each session
+ *
+ * Features:
+ * - Auto-load MEMORY.md for recent context
+ * - Auto-load ANCHORS.md for module navigation
+ * - Restore TODO state from .state.json
+ * - Inject session context summary
+ *
+ * Environment Variables:
+ * - CLAUDE_PROJECT_DIR: Project directory path
+ * - CLAUDE_SESSION_ID: Unique session identifier
+ */
+
+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 MEMORY_FILE = path.join(CLAUDE_DIR, 'MEMORY.md');
+const ANCHORS_FILE = path.join(CLAUDE_DIR, 'ANCHORS.md');
+const STATE_FILE = path.join(PROJECT_DIR, 'development', 'todos', '.state.json');
+const SESSION_ID = process.env.CLAUDE_SESSION_ID || 'unknown';
+
+/**
+ * Load memory file content (recent entries only)
+ */
+function loadMemory(days = 7) {
+  if (!fs.existsSync(MEMORY_FILE)) {
+    return { exists: false, content: '', entries: 0 };
+  }
+
+  const content = fs.readFileSync(MEMORY_FILE, 'utf-8');
+  const entries = content.split('## ').slice(1, days + 1);
+
+  return {
+    exists: true,
+    content: entries.length > 0 ? '## ' + entries.join('## ') : '',
+    entries: entries.length
+  };
+}
+
+/**
+ * Load anchors file for quick navigation
+ */
+function loadAnchors() {
+  if (!fs.existsSync(ANCHORS_FILE)) {
+    return { exists: false, content: '', modules: 0 };
+  }
+
+  const content = fs.readFileSync(ANCHORS_FILE, 'utf-8');
+  const moduleMatches = content.match(/##\s+[\w-]+/g) || [];
+
+  return {
+    exists: true,
+    content: content,
+    modules: moduleMatches.length
+  };
+}
+
+/**
+ * Load TODO state
+ */
+function loadTodoState() {
+  if (!fs.existsSync(STATE_FILE)) {
+    return { exists: false, active: 0, completed: 0 };
+  }
+
+  try {
+    const state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+    return {
+      exists: true,
+      active: state.active?.length || 0,
+      completed: state.completed?.length || 0,
+      lastUpdated: state.lastUpdated || null
+    };
+  } catch (e) {
+    return { exists: false, active: 0, completed: 0 };
+  }
+}
+
+/**
+ * Get project info
+ */
+function getProjectInfo() {
+  const pkgPath = path.join(PROJECT_DIR, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    return { name: path.basename(PROJECT_DIR), version: 'unknown' };
+  }
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return {
+      name: pkg.name || path.basename(PROJECT_DIR),
+      version: pkg.version || 'unknown'
+    };
+  } catch (e) {
+    return { name: path.basename(PROJECT_DIR), version: 'unknown' };
+  }
+}
+
+/**
+ * Generate session start context
+ */
+function generateSessionContext() {
+  const memory = loadMemory();
+  const anchors = loadAnchors();
+  const todos = loadTodoState();
+  const project = getProjectInfo();
+
+  const timestamp = new Date().toISOString();
+
+  // Build context object
+  const context = {
+    session: {
+      id: SESSION_ID,
+      startTime: timestamp,
+      project: project.name,
+      version: project.version
+    },
+    memory: {
+      loaded: memory.exists,
+      entries: memory.entries
+    },
+    anchors: {
+      loaded: anchors.exists,
+      modules: anchors.modules
+    },
+    todos: {
+      loaded: todos.exists,
+      active: todos.active,
+      completed: todos.completed
+    }
+  };
+
+  // Save session state
+  const sessionStateFile = path.join(CLAUDE_DIR, '.session-state.json');
+  try {
+    fs.writeFileSync(sessionStateFile, JSON.stringify(context, null, 2));
+  } catch (e) {
+    // Ignore write errors
+  }
+
+  return context;
+}
+
+/**
+ * Format session summary for output
+ */
+function formatSessionSummary(context) {
+  let summary = '';
+
+  summary += `\n📂 Session: ${context.session.project} v${context.session.version}\n`;
+
+  if (context.memory.loaded && context.memory.entries > 0) {
+    summary += `💾 Memory: ${context.memory.entries} entries loaded\n`;
+  }
+
+  if (context.anchors.loaded && context.anchors.modules > 0) {
+    summary += `🔖 Anchors: ${context.anchors.modules} modules indexed\n`;
+  }
+
+  if (context.todos.loaded && (context.todos.active > 0 || context.todos.completed > 0)) {
+    summary += `📋 TODOs: ${context.todos.active} active, ${context.todos.completed} completed\n`;
+  }
+
+  return summary;
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  try {
+    const context = generateSessionContext();
+
+    // Only output summary if there's meaningful context
+    const hasContext = context.memory.entries > 0 ||
+                       context.anchors.modules > 0 ||
+                       context.todos.active > 0;
+
+    if (hasContext) {
+      console.log(formatSessionSummary(context));
+    }
+
+    process.exit(0);
+  } catch (e) {
+    // Silent failure - don't interrupt session
+    process.exit(0);
+  }
+}
+
+// Run
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  loadMemory,
+  loadAnchors,
+  loadTodoState,
+  generateSessionContext,
+  formatSessionSummary
+};

package/template/.claude/hooks/memory-saver.cjs

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+/**
+ * Memory Saver Hook - SessionEnd Auto-Save System
+ *
+ * Claude Official Hook: SessionEnd
+ * Triggered: Once at the end of each session
+ *
+ * Features:
+ * - Auto-save session summary to MEMORY.md
+ * - Sync TODO state changes
+ * - Archive session state
+ * - Generate session statistics
+ *
+ * Environment Variables:
+ * - CLAUDE_PROJECT_DIR: Project directory path
+ * - CLAUDE_SESSION_ID: Unique session identifier
+ */
+
+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 MEMORY_FILE = path.join(CLAUDE_DIR, 'MEMORY.md');
+const SESSION_STATE_FILE = path.join(CLAUDE_DIR, '.session-state.json');
+const SESSIONS_DIR = path.join(CLAUDE_DIR, 'sessions');
+const STATE_FILE = path.join(PROJECT_DIR, 'development', 'todos', '.state.json');
+const SESSION_ID = process.env.CLAUDE_SESSION_ID || 'unknown';
+
+/**
+ * Ensure directories exist
+ */
+function ensureDirectories() {
+  [CLAUDE_DIR, SESSIONS_DIR].forEach(dir => {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  });
+}
+
+/**
+ * Load session state from SessionStart
+ */
+function loadSessionState() {
+  if (!fs.existsSync(SESSION_STATE_FILE)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(SESSION_STATE_FILE, 'utf-8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Calculate session duration
+ */
+function calculateDuration(startTime) {
+  if (!startTime) return 'unknown';
+
+  const start = new Date(startTime);
+  const now = new Date();
+  const diffMs = now - start;
+  const diffMins = Math.floor(diffMs / 60000);
+
+  if (diffMins < 1) return 'less than 1 minute';
+  if (diffMins < 60) return `${diffMins} minutes`;
+
+  const hours = Math.floor(diffMins / 60);
+  const mins = diffMins % 60;
+  return `${hours}h ${mins}m`;
+}
+
+/**
+ * Save session summary to MEMORY.md
+ */
+function saveToMemory(sessionState) {
+  ensureDirectories();
+
+  const now = new Date();
+  const dateStr = now.toISOString().split('T')[0];
+  const duration = sessionState?.session?.startTime
+    ? calculateDuration(sessionState.session.startTime)
+    : 'unknown';
+
+  // Generate session entry
+  const entry = `### Session ${now.toISOString()}
+
+- **Duration**: ${duration}
+- **Project**: ${sessionState?.session?.project || 'unknown'}
+- **Memory entries**: ${sessionState?.memory?.entries || 0}
+- **TODOs**: ${sessionState?.todos?.active || 0} active, ${sessionState?.todos?.completed || 0} completed
+
+`;
+
+  // Read existing memory
+  let content = '';
+  if (fs.existsSync(MEMORY_FILE)) {
+    content = fs.readFileSync(MEMORY_FILE, 'utf-8');
+  }
+
+  // Check if today's section exists
+  const todaySection = `## ${dateStr}`;
+  if (content.includes(todaySection)) {
+    // Append to today's section
+    const parts = content.split(todaySection);
+    const beforeToday = parts[0];
+    const afterHeader = parts[1];
+
+    // Find next section or end
+    const nextSectionMatch = afterHeader.match(/\n## \d{4}-\d{2}-\d{2}/);
+    if (nextSectionMatch) {
+      const insertPoint = nextSectionMatch.index;
+      const todayContent = afterHeader.slice(0, insertPoint);
+      const restContent = afterHeader.slice(insertPoint);
+      content = beforeToday + todaySection + todayContent + entry + restContent;
+    } else {
+      content = beforeToday + todaySection + afterHeader + entry;
+    }
+  } else {
+    // Create new day section at the top
+    const header = content.startsWith('#') ? '' : '# Memory\n\n<!-- Project memory updated by AI -->\n\n';
+    const existingContent = content.replace(/^# Memory\n+(?:<!-- [^>]+ -->\n+)?/, '');
+    content = header + `${todaySection}\n\n${entry}` + existingContent;
+  }
+
+  // Keep only last 7 days
+  const sections = content.split(/(?=\n## \d{4}-\d{2}-\d{2})/);
+  const header = sections[0];
+  const daySections = sections.slice(1, 8); // Keep 7 days max
+  content = header + daySections.join('');
+
+  fs.writeFileSync(MEMORY_FILE, content.trim() + '\n');
+}
+
+/**
+ * Archive session state
+ */
+function archiveSession(sessionState) {
+  ensureDirectories();
+
+  const now = new Date();
+  const filename = `session_${now.toISOString().replace(/[:.]/g, '-')}.json`;
+  const filepath = path.join(SESSIONS_DIR, filename);
+
+  const archiveData = {
+    ...sessionState,
+    endTime: now.toISOString(),
+    duration: sessionState?.session?.startTime
+      ? calculateDuration(sessionState.session.startTime)
+      : 'unknown'
+  };
+
+  fs.writeFileSync(filepath, JSON.stringify(archiveData, null, 2));
+
+  // Clean up old sessions (keep last 20)
+  const files = fs.readdirSync(SESSIONS_DIR)
+    .filter(f => f.startsWith('session_') && f.endsWith('.json'))
+    .sort()
+    .reverse();
+
+  if (files.length > 20) {
+    files.slice(20).forEach(f => {
+      try {
+        fs.unlinkSync(path.join(SESSIONS_DIR, f));
+      } catch (e) {
+        // Ignore deletion errors
+      }
+    });
+  }
+
+  return filename;
+}
+
+/**
+ * Update TODO state sync timestamp
+ */
+function syncTodoState() {
+  if (!fs.existsSync(STATE_FILE)) {
+    return;
+  }
+
+  try {
+    const state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+    state.lastSynced = new Date().toISOString();
+    state.sessionId = SESSION_ID;
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  } catch (e) {
+    // Ignore sync errors
+  }
+}
+
+/**
+ * Clean up session state file
+ */
+function cleanupSessionState() {
+  if (fs.existsSync(SESSION_STATE_FILE)) {
+    try {
+      fs.unlinkSync(SESSION_STATE_FILE);
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+  }
+}
+
+/**
+ * Format session end summary
+ */
+function formatEndSummary(sessionState, archiveFile) {
+  let summary = '';
+
+  const duration = sessionState?.session?.startTime
+    ? calculateDuration(sessionState.session.startTime)
+    : 'unknown';
+
+  summary += `\n✅ Session ended (${duration})\n`;
+  summary += `💾 Memory saved to MEMORY.md\n`;
+  summary += `📁 Archived: ${archiveFile}\n`;
+
+  return summary;
+}
+
+/**
+ * Main execution
+ */
+function main() {
+  try {
+    const sessionState = loadSessionState();
+
+    if (sessionState) {
+      // Save to memory
+      saveToMemory(sessionState);
+
+      // Archive session
+      const archiveFile = archiveSession(sessionState);
+
+      // Sync TODO state
+      syncTodoState();
+
+      // Output summary
+      console.log(formatEndSummary(sessionState, archiveFile));
+    }
+
+    // Clean up
+    cleanupSessionState();
+
+    process.exit(0);
+  } catch (e) {
+    // Silent failure - don't interrupt session end
+    cleanupSessionState();
+    process.exit(0);
+  }
+}
+
+// Run
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  loadSessionState,
+  saveToMemory,
+  archiveSession,
+  syncTodoState,
+  calculateDuration,
+  formatEndSummary
+};

package/template/.claude/hooks/rag-skill-loader.cjs

@@ -13,6 +13,10 @@ const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 const RAG_DIR = path.join(PROJECT_DIR, '.claude/rag');
 const SKILL_INDEX_FILE = path.join(RAG_DIR, 'skill-index.json');
 const SKILLS_DIR = path.join(PROJECT_DIR, '.claude/skills');
+const CACHE_FILE = path.join(RAG_DIR, '.match-cache.json');
+
+// 缓存配置
+const CACHE_TTL = 300000; // 5分钟缓存有效期
 
 // 技能关键词匹配权重
 const KEYWORD_WEIGHTS = {
@@ -21,6 +25,67 @@ const KEYWORD_WEIGHTS = {
   related: 0.5     // 相关匹配
 };
 
+// 简单哈希函数
+function hashInput(input) {
+  let hash = 0;
+  for (let i = 0; i < input.length; i++) {
+    const char = input.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash = hash & hash;
+  }
+  return hash.toString(16);
+}
+
+// 加载缓存
+function loadCache() {
+  if (!fs.existsSync(CACHE_FILE)) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
+  } catch (e) {
+    return {};
+  }
+}
+
+// 保存缓存
+function saveCache(cache) {
+  try {
+    // 清理过期条目
+    const now = Date.now();
+    const cleaned = {};
+    for (const [key, value] of Object.entries(cache)) {
+      if (now - value.timestamp < (value.ttl || CACHE_TTL)) {
+        cleaned[key] = value;
+      }
+    }
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(cleaned, null, 2));
+  } catch (e) {
+    // 忽略保存错误
+  }
+}
+
+// 从缓存获取结果
+function getCachedResult(inputHash) {
+  const cache = loadCache();
+  const cached = cache[inputHash];
+  if (cached && Date.now() - cached.timestamp < (cached.ttl || CACHE_TTL)) {
+    return cached.result;
+  }
+  return null;
+}
+
+// 保存结果到缓存
+function setCachedResult(inputHash, result) {
+  const cache = loadCache();
+  cache[inputHash] = {
+    result,
+    timestamp: Date.now(),
+    ttl: CACHE_TTL
+  };
+  saveCache(cache);
+}
+
 // 加载技能索引
 function loadSkillIndex() {
   if (!fs.existsSync(SKILL_INDEX_FILE)) {
@@ -134,12 +199,27 @@ function main() {
       process.exit(0);
     }
 
-    const analysis = analyzeInput(toolInput);
-    if (analysis.keywords.length === 0) {
-      process.exit(0);
+    // 检查缓存
+    const inputHash = hashInput(toolInput);
+    const cachedResult = getCachedResult(inputHash);
+
+    let matches;
+    if (cachedResult) {
+      // 使用缓存结果
+      matches = cachedResult;
+    } else {
+      // 分析并匹配
+      const analysis = analyzeInput(toolInput);
+      if (analysis.keywords.length === 0) {
+        process.exit(0);
+      }
+
+      matches = matchSkills(analysis, skillIndex);
+
+      // 缓存结果
+      setCachedResult(inputHash, matches);
     }
 
-    const matches = matchSkills(analysis, skillIndex);
     if (matches.length === 0) {
       process.exit(0);
     }