sumulige-claude 1.3.1 → 1.3.2

package/.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/.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/.claude/sessions/session_2026-01-22T13-07-26-625Z.json

@@ -0,0 +1,23 @@
+{
+  "session": {
+    "id": "unknown",
+    "startTime": "2026-01-22T13:06:23.872Z",
+    "project": "sumulige-claude",
+    "version": "1.3.1"
+  },
+  "memory": {
+    "loaded": true,
+    "entries": 4
+  },
+  "anchors": {
+    "loaded": true,
+    "modules": 0
+  },
+  "todos": {
+    "loaded": true,
+    "active": 0,
+    "completed": 0
+  },
+  "endTime": "2026-01-22T13:07:26.625Z",
+  "duration": "1 minutes"
+}

package/.claude/settings.json

@@ -1,4 +1,44 @@
 {
+  "env": {
+    "ENABLE_TOOL_SEARCH": "true",
+    "DISABLE_AUTOUPDATER": "1"
+  },
+  "SessionStart": [
+    {
+      "matcher": {},
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/memory-loader.cjs",
+          "timeout": 2000
+        }
+      ]
+    }
+  ],
+  "SessionEnd": [
+    {
+      "matcher": {},
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/memory-saver.cjs",
+          "timeout": 3000
+        }
+      ]
+    }
+  ],
+  "PreCompact": [
+    {
+      "matcher": {},
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/auto-handoff.cjs",
+          "timeout": 5000
+        }
+      ]
+    }
+  ],
   "UserPromptSubmit": [
     {
       "matcher": {},

package/.claude/settings.local.json

@@ -128,7 +128,11 @@
       "Bash(/opt/homebrew/Cellar/node/25.3.0/bin/npm view sumulige-claude versions --json)",
       "Bash(/opt/homebrew/Cellar/node/25.3.0/bin/npx sumulige-claude@1.3.0 sync)",
       "WebFetch(domain:raw.githubusercontent.com)",
-      "Bash(/opt/homebrew/Cellar/node/25.3.0/bin/npm version 1.3.1 --no-git-tag-version)"
+      "Bash(/opt/homebrew/Cellar/node/25.3.0/bin/npm version 1.3.1 --no-git-tag-version)",
+      "Bash(/opt/homebrew/Cellar/node/25.3.0/bin/node:*)",
+      "WebFetch(domain:docs.anthropic.com)",
+      "Bash(CLAUDE_PROJECT_DIR=\"/Users/sumulige/Documents/Antigravity/sumulige-claude\" /opt/homebrew/Cellar/node/25.3.0/bin/node:*)",
+      "Bash(CLAUDE_PROJECT_DIR=\"/Users/sumulige/Documents/Antigravity/sumulige-claude\" /opt/homebrew/Cellar/node/25.3.0/bin/node .claude/hooks/memory-saver.cjs)"
     ]
   },
   "hooks": {

package/.claude/skills/api-tester/SKILL.md

@@ -0,0 +1,61 @@
+# Api Tester
+
+> 简短描述这个技能的作用（一句话）
+
+**版本**: 1.0.0
+**作者**: @username
+**标签**: [category1, category2]
+**难度**: 初级/中级/高级
+
+---
+
+## 概述
+
+详细描述这个技能的功能和用途。
+
+## 适用场景
+
+- 场景 1
+- 场景 2
+- 场景 3
+
+## 触发关键词
+
+```
+keyword1, keyword2, "exact phrase"
+```
+
+## 使用方法
+
+### 基础用法
+
+```bash
+# 示例命令
+your-command-here
+```
+
+### 高级用法
+
+```yaml
+# 配置示例
+key: value
+```
+
+## 输出格式
+
+描述这个技能的输出结果格式。
+
+## 注意事项
+
+- 注意事项 1
+- 注意事项 2
+
+## 相关技能
+
+- [related-skill](../related-skill/)
+- [another-skill](../another-skill/)
+
+## 更新日志
+
+### 1.0.0 (YYYY-MM-DD)
+- 初始版本

package/.claude/skills/api-tester/examples/basic.md

@@ -0,0 +1,3 @@
+# Basic Example for api-tester
+
+Replace this with your actual example.

package/.claude/skills/api-tester/metadata.yaml

@@ -0,0 +1,30 @@
+# Skill Metadata
+# 这个文件定义技能的基本信息，用于自动发现和索引
+
+name: api-tester
+version: 1.0.0
+author: @username
+description: 简短描述技能功能
+
+tags:
+  - category1
+  - category2
+
+triggers:
+  - keyword1
+  - keyword2
+  - "exact phrase"
+
+dependencies: []  # 依赖的其他技能
+
+difficulty: beginner  # beginner | intermediate | advanced
+
+# 模板文件
+templates:
+  - name: default
+    file: templates/default.md
+
+# 示例文件
+examples:
+  - name: basic
+    file: examples/basic.md

package/.claude/skills/api-tester/templates/default.md

@@ -0,0 +1,3 @@
+# Default Template for api-tester
+
+Replace this with your actual template.