sumulige-claude 1.1.2 → 1.2.1

package/.claude/templates/hooks/user-response-submit.cjs.template

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+/**
+ * [Hook Name] - UserResponseSubmit Hook Template
+ *
+ * 触发时机: AI 返回响应后
+ * 环境变量:
+ *   - CLAUDE_PROJECT_DIR: 项目根目录
+ *   - CLAUDE_RESPONSE_CONTENT: 响应内容
+ *
+ * @version 1.0.0
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ============================================================
+// 标准头部 - 所有 hooks 必须包含
+// ============================================================
+
+const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+// 如果不在 Claude Code 环境中运行，静默退出
+if (!process.env.CLAUDE_PROJECT_DIR) {
+  process.exit(0);
+}
+
+// ============================================================
+// 配置区域
+// ============================================================
+
+const CONFIG = {
+  enabled: true,
+  verbose: false,
+};
+
+// ============================================================
+// 工具函数
+// ============================================================
+
+function log(...args) {
+  if (CONFIG.verbose) {
+    console.error('[Hook]', ...args);
+  }
+}
+
+function safeReadFile(filePath, defaultValue = '') {
+  try {
+    return fs.readFileSync(filePath, 'utf-8');
+  } catch (e) {
+    return defaultValue;
+  }
+}
+
+function safeWriteFile(filePath, content) {
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, 'utf-8');
+    return true;
+  } catch (e) {
+    log('Write error:', e.message);
+    return false;
+  }
+}
+
+// ============================================================
+// Hook 核心逻辑
+// ============================================================
+
+function main() {
+  try {
+    const responseContent = process.env.CLAUDE_RESPONSE_CONTENT || '';
+
+    log('Response length:', responseContent.length);
+
+    // ===== 在这里实现你的 hook 逻辑 =====
+
+    // 示例: 记录响应统计
+    const statsFile = path.join(PROJECT_DIR, '.claude/hooks/.response-stats.json');
+    const stats = JSON.parse(safeReadFile(statsFile, '{}'));
+    stats.totalResponses = (stats.totalResponses || 0) + 1;
+    stats.totalChars = (stats.totalChars || 0) + responseContent.length;
+    stats.lastUpdate = new Date().toISOString();
+    safeWriteFile(statsFile, JSON.stringify(stats, null, 2));
+
+    // ===== Hook 逻辑结束 =====
+
+  } catch (error) {
+    log('Error:', error.message);
+  }
+
+  process.exit(0);
+}
+
+main();

package/.claude/templates/hooks/validate.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+/**
+ * Hook Validator - 检查 hook 是否符合最佳实践
+ *
+ * 使用方法:
+ *   node validate.js [hook-file]
+ *
+ * 示例:
+ *   node validate.js ../my-hook.cjs
+ *   node validate.js *.cjs
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CHECKS = {
+  ENV_FALLBACK: {
+    name: '环境变量 fallback',
+    pattern: /process\.env\.CLAUDE_PROJECT_DIR\s*\|\|/,
+    required: true,
+    error: '缺少 CLAUDE_PROJECT_DIR fallback (|| process.cwd())'
+  },
+
+  SILENT_EXIT: {
+    name: '静默退出检查',
+    pattern: /if\s*\(\s*!process\.env\.CLAUDE_PROJECT_DIR/,
+    required: true,
+    error: '缺少非项目环境的静默退出检查'
+  },
+
+  ERROR_HANDLING: {
+    name: '错误处理',
+    pattern: /try\s*\{/,
+    required: true,
+    error: '缺少 try-catch 错误处理'
+  },
+
+  SAFE_EXIT: {
+    name: '安全退出',
+    pattern: /process\.exit\(0\)/,
+    required: true,
+    error: '缺少明确的 process.exit(0)'
+  },
+
+  NO_STDOUT: {
+    name: '避免 stdout 输出',
+    pattern: /console\.log\(/,
+    required: false,
+    error: '检测到 console.log - 建议使用 console.error 用于调试'
+  },
+
+  SAFE_MKDIR: {
+    name: '安全创建目录',
+    pattern: /mkdirSync.*recursive/,
+    required: true,
+    error: '目录创建缺少 { recursive: true } 选项'
+  }
+};
+
+/**
+ * 验证单个 hook 文件
+ */
+function validateHook(filePath) {
+  const results = {
+    file: filePath,
+    passed: 0,
+    failed: 0,
+    warnings: 0,
+    checks: []
+  };
+
+  if (!fs.existsSync(filePath)) {
+    results.error = '文件不存在';
+    return results;
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+
+  for (const [key, check] of Object.entries(CHECKS)) {
+    const passed = check.pattern.test(content);
+
+    if (check.required) {
+      if (passed) {
+        results.passed++;
+      } else {
+        results.failed++;
+      }
+    } else {
+      // 可选检查作为警告
+      if (passed) {
+        results.warnings++;
+      }
+    }
+
+    results.checks.push({
+      name: check.name,
+      passed: check.required ? passed : !passed,
+      required: check.required,
+      error: check.error
+    });
+  }
+
+  return results;
+}
+
+/**
+ * 打印验证结果
+ */
+function printResults(results) {
+  console.log(`\n📎 ${path.basename(results.file)}`);
+  console.log('─'.repeat(50));
+
+  if (results.error) {
+    console.log(`❌ ${results.error}`);
+    return;
+  }
+
+  for (const check of results.checks) {
+    if (check.passed) {
+      console.log(`✅ ${check.name}`);
+    } else if (check.required) {
+      console.log(`❌ ${check.name}`);
+      console.log(`   ${check.error}`);
+    } else {
+      console.log(`⚠️  ${check.name}`);
+      console.log(`   ${check.error}`);
+    }
+  }
+
+  const total = results.passed + results.failed;
+  const score = total > 0 ? Math.round((results.passed / total) * 100) : 0;
+
+  console.log('─'.repeat(50));
+  console.log(`得分: ${score}% | ✅ ${results.passed} | ❌ ${results.failed} | ⚠️  ${results.warnings}`);
+}
+
+/**
+ * 主函数
+ */
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.log(`
+🔍 Hook Validator - 检查 hook 最佳实践
+
+使用方法:
+  node validate.js <hook-file>
+  node validate.js *.cjs
+
+示例:
+  node validate.js my-hook.cjs
+  node validate.js ../*.cjs
+    `);
+    process.exit(0);
+  }
+
+  let allPassed = true;
+
+  for (const arg of args) {
+    const results = validateHook(arg);
+    printResults(results);
+
+    if (results.failed > 0) {
+      allPassed = false;
+    }
+  }
+
+  console.log('');
+  process.exit(allPassed ? 0 : 1);
+}
+
+main();

package/.claude/workflow/document-scanner.js

@@ -0,0 +1,426 @@
+/**
+ * Document Scanner - Extract content and metadata from local files
+ *
+ * Supports:
+ * - Text extraction from multiple file formats
+ * - Metadata extraction (word count, headings, links)
+ * - Content checksum for change detection
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// ============================================================================
+// Configuration
+// ============================================================================
+
+const MAX_CONTENT_SIZE = 500 * 1024; // 500KB - don't store content if larger
+const MAX_SNIPPET_SIZE = 2000; // Store snippet for large files
+
+// Supported file types for content scanning
+const SCANNABLE_TYPES = [
+  '.md', '.markdown',  // Markdown
+  '.txt',              // Plain text
+  '.json', '.yaml', '.yml',  // Config files
+  '.js', '.ts', '.jsx', '.tsx',  // JavaScript/TypeScript
+  '.py', '.rs', '.go', '.java', '.c', '.cpp', '.h', '.hpp',  // Code
+  '.sh', '.bash', '.zsh', '.fish',  // Shell scripts
+  '.css', '.scss', '.less',  // Stylesheets
+  '.html', '.htm', '.xml',  // Markup
+  '.sql', '.graphql', '.gql'  // Query languages
+];
+
+// ============================================================================
+// Document Scanner Class
+// ============================================================================
+
+class DocumentScanner {
+  /**
+   * Check if a file type is scannable
+   */
+  static isScannable(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return SCANNABLE_TYPES.includes(ext);
+  }
+
+  /**
+   * Scan a file and extract metadata
+   */
+  static scanFile(filePath, options = {}) {
+    const {
+      includeContent = true,
+      maxContentSize = MAX_CONTENT_SIZE
+    } = options;
+
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+
+    const stats = fs.statSync(filePath);
+    const ext = path.extname(filePath).toLowerCase();
+
+    // Basic metadata
+    const metadata = {
+      path: filePath,
+      size: stats.size,
+      lastModified: stats.mtimeMs,
+      contentType: this.getMimeType(ext),
+      extension: ext
+    };
+
+    // If file is too large or not scannable, skip content
+    if (!this.isScannable(filePath) || stats.size === 0) {
+      return {
+        ...metadata,
+        scannable: false,
+        wordCount: 0,
+        headings: [],
+        links: [],
+      };
+    }
+
+    // Read file content
+    let content;
+    try {
+      content = fs.readFileSync(filePath, 'utf-8');
+    } catch (error) {
+      return {
+        ...metadata,
+        scannable: false,
+        error: error.message
+      };
+    }
+
+    // Calculate checksum
+    const checksum = crypto
+      .createHash('md5')
+      .update(content)
+      .digest('hex');
+
+    // Extract metadata based on file type
+    const extracted = this.extractMetadata(content, ext);
+
+    // Determine whether to store full content or just snippet
+    const shouldStoreContent = includeContent && content.length <= maxContentSize;
+
+    return {
+      ...metadata,
+      scannable: true,
+      checksum,
+      wordCount: extracted.wordCount,
+      lineCount: extracted.lineCount,
+      headings: extracted.headings,
+      links: extracted.links,
+      codeBlocks: extracted.codeBlocks,
+      frontMatter: extracted.frontMatter,
+      // Content or snippet
+      content: shouldStoreContent ? content : null,
+      snippet: shouldStoreContent ? null : content.substring(0, MAX_SNIPPET_SIZE)
+    };
+  }
+
+  /**
+   * Extract metadata from content based on file type
+   */
+  static extractMetadata(content, ext) {
+    const lines = content.split('\n');
+    const wordCount = this.countWords(content);
+    const lineCount = lines.length;
+
+    let headings = [];
+    let links = [];
+    let codeBlocks = [];
+    let frontMatter = null;
+
+    // Markdown-specific extraction
+    if (['.md', '.markdown'].includes(ext)) {
+      const mdResult = this.extractMarkdownMetadata(content);
+      headings = mdResult.headings;
+      links = mdResult.links;
+      codeBlocks = mdResult.codeBlocks;
+      frontMatter = mdResult.frontMatter;
+    }
+    // Code-specific extraction
+    else if (['.js', '.ts', '.jsx', '.tsx', '.py', '.rs', '.go'].includes(ext)) {
+      const codeResult = this.extractCodeMetadata(content, ext);
+      headings = codeResult.headings; // Functions/classes as headings
+      links = codeResult.links; // Import/require statements
+    }
+
+    return {
+      wordCount,
+      lineCount,
+      headings,
+      links,
+      codeBlocks,
+      frontMatter
+    };
+  }
+
+  /**
+   * Extract Markdown-specific metadata
+   */
+  static extractMarkdownMetadata(content) {
+    const headings = [];
+    const links = [];
+    const codeBlocks = [];
+    let frontMatter = null;
+
+    const lines = content.split('\n');
+    let inCodeBlock = false;
+    let codeBlockLang = null;
+    let currentCodeBlock = [];
+
+    // Check for YAML front matter
+    if (lines[0] === '---') {
+      const endIdx = lines.slice(1).findIndex(line => line === '---');
+      if (endIdx > 0) {
+        const frontMatterContent = lines.slice(1, endIdx + 1).join('\n');
+        frontMatter = this.parseFrontMatter(frontMatterContent);
+      }
+    }
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Track code blocks
+      if (line.startsWith('```')) {
+        if (!inCodeBlock) {
+          inCodeBlock = true;
+          codeBlockLang = line.substring(3).trim() || 'text';
+          currentCodeBlock = [];
+        } else {
+          codeBlocks.push({
+            language: codeBlockLang,
+            lineStart: i - currentCodeBlock.length,
+            preview: currentCodeBlock.slice(0, 3).join('\n')
+          });
+          inCodeBlock = false;
+          currentCodeBlock = [];
+        }
+        continue;
+      }
+
+      if (inCodeBlock) {
+        currentCodeBlock.push(line);
+        continue;
+      }
+
+      // Extract headings
+      const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+      if (headingMatch) {
+        const level = headingMatch[1].length;
+        const text = headingMatch[2].trim();
+        headings.push({ level, text, line: i + 1 });
+      }
+
+      // Extract links
+      const linkMatch = line.match(/\[([^\]]+)\]\(([^)]+)\)/g);
+      if (linkMatch) {
+        linkMatch.forEach(link => {
+          const match = link.match(/\[([^\]]+)\]\(([^)]+)\)/);
+          if (match) {
+            links.push({ text: match[1], url: match[2] });
+          }
+        });
+      }
+    }
+
+    return { headings, links, codeBlocks, frontMatter };
+  }
+
+  /**
+   * Extract code-specific metadata (functions, classes, imports)
+   */
+  static extractCodeMetadata(content, ext) {
+    const headings = [];
+    const links = [];
+
+    const lines = content.split('\n');
+
+    // Patterns for different languages
+    const patterns = {
+      '.js': { func: /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/, class: /^\s*class\s+(\w+)/, import: /^\s*import\s+.*from\s+['"]([^'"]+)['"]/ },
+      '.ts': { func: /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/, class: /^\s*class\s+(\w+)/, import: /^\s*import\s+.*from\s+['"]([^'"]+)['"]/ },
+      '.jsx': { func: /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/, class: /^\s*class\s+(\w+)/, import: /^\s*import\s+.*from\s+['"]([^'"]+)['"]/ },
+      '.tsx': { func: /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/, class: /^\s*class\s+(\w+)/, import: /^\s*import\s+.*from\s+['"]([^'"]+)['"]/ },
+      '.py': { func: /^\s*def\s+(\w+)\s*\(/, class: /^\s*class\s+(\w+)\s*:/, import: /^\s*(?:import|from)\s+(\w+)/ },
+      '.rs': { func: /^\s*(?:pub\s+)?fn\s+(\w+)\s*\(/, class: /^\s*(?:pub\s+)?(struct|enum|trait)\s+(\w+)/, import: /^\s*use\s+([^;]+);/ },
+      '.go': { func: /^\s*func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)\s*\(/, class: /^\s*type\s+(\w+)\s+struct/, import: /^\s*import\s+(?:\(|")([^")]+)/ }
+    };
+
+    const lang = patterns[ext] || patterns['.js'];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Extract functions
+      const funcMatch = line.match(lang.func);
+      if (funcMatch) {
+        headings.push({ type: 'function', name: funcMatch[1], line: i + 1 });
+      }
+
+      // Extract classes
+      const classMatch = line.match(lang.class);
+      if (classMatch) {
+        const name = classMatch[2] || classMatch[1];
+        headings.push({ type: 'class', name, line: i + 1 });
+      }
+
+      // Extract imports
+      const importMatch = line.match(lang.import);
+      if (importMatch) {
+        links.push({ type: 'import', name: importMatch[1], line: i + 1 });
+      }
+    }
+
+    return { headings, links };
+  }
+
+  /**
+   * Parse YAML front matter
+   */
+  static parseFrontMatter(content) {
+    const result = {};
+    const lines = content.split('\n');
+
+    for (const line of lines) {
+      const match = line.match(/^(\w+):\s*(.+)$/);
+      if (match) {
+        result[match[1]] = match[2].trim();
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Count words in content (rough estimate for mixed content)
+   */
+  static countWords(content) {
+    // For code files, count tokens more accurately
+    // For text files, count words
+    const tokens = content
+      .replace(/\s+/g, ' ')
+      .replace(/[{}();,.<>[\]]/g, ' ')
+      .split(' ')
+      .filter(t => t.length > 0);
+
+    return tokens.length;
+  }
+
+  /**
+   * Get MIME type for extension
+   */
+  static getMimeType(ext) {
+    const mimeTypes = {
+      '.md': 'text/markdown',
+      '.markdown': 'text/markdown',
+      '.txt': 'text/plain',
+      '.json': 'application/json',
+      '.yaml': 'text/yaml',
+      '.yml': 'text/yaml',
+      '.js': 'text/javascript',
+      '.ts': 'text/typescript',
+      '.jsx': 'text/jsx',
+      '.tsx': 'text/tsx',
+      '.py': 'text/x-python',
+      '.rs': 'text/x-rust',
+      '.go': 'text/x-go',
+      '.java': 'text/x-java',
+      '.c': 'text/x-c',
+      '.cpp': 'text/x-c++',
+      '.h': 'text/x-c',
+      '.hpp': 'text/x-c++',
+      '.sh': 'text/x-shellscript',
+      '.bash': 'text/x-shellscript',
+      '.css': 'text/css',
+      '.scss': 'text/x-scss',
+      '.less': 'text/x-less',
+      '.html': 'text/html',
+      '.htm': 'text/html',
+      '.xml': 'text/xml',
+      '.sql': 'text/x-sql',
+      '.graphql': 'text/x-graphql',
+      '.gql': 'text/x-graphql'
+    };
+    return mimeTypes[ext.toLowerCase()] || 'text/plain';
+  }
+
+  /**
+   * Scan a directory recursively
+   */
+  static scanDirectory(dirPath, options = {}) {
+    const {
+      recursive = true,
+      maxDepth = 10,
+      includePatterns = [],
+      excludePatterns = ['node_modules', '.git', 'dist', 'build', 'coverage']
+    } = options;
+
+    if (!fs.existsSync(dirPath)) {
+      throw new Error(`Directory not found: ${dirPath}`);
+    }
+
+    const results = [];
+    const scanQueue = [{ dir: dirPath, depth: 0 }];
+
+    while (scanQueue.length > 0) {
+      const { dir, depth } = scanQueue.shift();
+
+      if (depth > maxDepth) continue;
+
+      let entries;
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+      } catch (error) {
+        continue; // Skip directories we can't read
+      }
+
+      for (const entry of entries) {
+        // Skip excluded directories
+        if (entry.isDirectory() && excludePatterns.includes(entry.name)) {
+          continue;
+        }
+
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory() && recursive) {
+          scanQueue.push({ dir: fullPath, depth: depth + 1 });
+        } else if (entry.isFile()) {
+          // Check include patterns
+          if (includePatterns.length > 0) {
+            const matches = includePatterns.some(pattern => {
+              if (pattern instanceof RegExp) {
+                return pattern.test(fullPath);
+              }
+              return fullPath.includes(pattern);
+            });
+            if (!matches) continue;
+          }
+
+          try {
+            const scanResult = this.scanFile(fullPath, options);
+            results.push(scanResult);
+          } catch (error) {
+            // Skip files that can't be scanned
+          }
+        }
+      }
+    }
+
+    return results;
+  }
+}
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+module.exports = {
+  DocumentScanner,
+  SCANNABLE_TYPES,
+  MAX_CONTENT_SIZE,
+  MAX_SNIPPET_SIZE
+};