sumulige-claude 1.4.0 → 1.5.0

package/.claude/MEMORY.md

@@ -1,3 +1,29 @@
+## 2026-01-23
+
+### Session: 前端设计灵感 & 3D 可视化
+
+- **主题**: 从 skills.sh 获取前端创意设计灵感
+- **产出**:
+  - `demos/power-3d-scatter.html` - Three.js 功率-时间-心率 3D 散点图 demo
+  - 安装了 5 个设计相关 skills (web-design-guidelines, react-best-practices, threejs-fundamentals 等)
+
+- **关联项目**: SynapseFlow / ApexOS
+  - 优化路线图: `synapseflow/docs/FRONTEND_OPTIMIZATION_ROADMAP.md`
+
+- **核心改进方向**:
+  1. Typography: tabular-nums, text-wrap, 字体升级
+  2. 数据可视化: 曲线动画, hover 精确值, 历史对比
+  3. 3D 散点图: 接入真实数据, 区间筛选, 时间刷选
+  4. 交互: URL 状态同步, focus states, loading states
+  5. 品牌: 避免 AI 审美, 生成式视觉元素
+
+- **待办**:
+  - [ ] 3D 散点图接入 ApexOS 真实 FIT 数据
+  - [ ] Power Duration 曲线添加绘制动画
+  - [ ] iLevels 进度条动画优化
+
+---
+
 ## 2026-01-22
 
 ### Session 2026-01-22T13:07:26.622Z

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

@@ -2,6 +2,21 @@
   "$schema": "hook-registry-schema.json",
   "$comment": "Hook Dispatcher Registry - Controls which hooks run and when",
 
+  "plan-gate": {
+    "events": ["PreToolUse"],
+    "toolMatch": ["Write", "Edit"],
+    "enabled": true,
+    "description": "强制规划检查 - 无批准计划阻止 Write/Edit"
+  },
+
+  "live-quality": {
+    "events": ["PostToolUse"],
+    "toolMatch": ["Write", "Edit"],
+    "debounce": 1000,
+    "enabled": true,
+    "description": "实时质量检查 - 写入后立即检查代码质量"
+  },
+
   "thinking-silent": {
     "events": ["AgentStop"],
     "debounce": 5000,

package/.claude/hooks/live-quality.cjs

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+/**
+ * Live Quality Gate - 实时质量检查
+ *
+ * PostToolUse 钩子：每次 Write/Edit 后立即检查代码质量
+ *
+ * 检查项：
+ * 1. 文件行数 ≤ 800
+ * 2. 函数长度 ≤ 50 行
+ * 3. 无硬编码密钥
+ * 4. 无 console.log
+ * 5. 基础代码规范
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const GATE_CONFIG_FILE = path.join(PROJECT_DIR, '.claude/quality-gate.json');
+
+// 默认规则配置
+const DEFAULT_RULES = {
+  maxFileLines: 800,
+  maxFunctionLines: 50,
+  forbiddenPatterns: [
+    {
+      pattern: /console\.(log|debug|info)\s*\(/g,
+      message: '禁止 console.log/debug/info',
+      severity: 'warn'
+    },
+    {
+      pattern: /api[_-]?key\s*[:=]\s*['"][^'"]{10,}['"]/gi,
+      message: '检测到可能的硬编码 API Key',
+      severity: 'error'
+    },
+    {
+      pattern: /password\s*[:=]\s*['"][^'"]+['"]/gi,
+      message: '检测到可能的硬编码密码',
+      severity: 'error'
+    },
+    {
+      pattern: /secret\s*[:=]\s*['"][^'"]{10,}['"]/gi,
+      message: '检测到可能的硬编码 Secret',
+      severity: 'error'
+    },
+    {
+      pattern: /TODO:|FIXME:|HACK:|XXX:/g,
+      message: '存在待处理标记',
+      severity: 'info'
+    }
+  ]
+};
+
+// 豁免模式
+const EXEMPT_PATTERNS = [
+  /\.md$/,
+  /\.json$/,
+  /\.test\./,
+  /\.spec\./,
+  /__tests__/,
+  /node_modules/,
+  /\.min\./,
+  /\.bundle\./,
+  /dist\//,
+  /build\//
+];
+
+/**
+ * 获取配置
+ */
+function getConfig() {
+  try {
+    if (fs.existsSync(GATE_CONFIG_FILE)) {
+      const config = JSON.parse(fs.readFileSync(GATE_CONFIG_FILE, 'utf-8'));
+      return { ...DEFAULT_RULES, ...(config.liveQuality || {}) };
+    }
+  } catch (e) {
+    // 使用默认配置
+  }
+  return DEFAULT_RULES;
+}
+
+/**
+ * 检查文件是否豁免
+ */
+function isExempt(filePath) {
+  if (!filePath) return true;
+  return EXEMPT_PATTERNS.some(pattern => pattern.test(filePath));
+}
+
+/**
+ * 检测函数长度（简单实现）
+ */
+function detectLongFunctions(content, maxLines) {
+  const issues = [];
+  const lines = content.split('\n');
+
+  // 简单的函数检测：匹配 function 或箭头函数
+  const functionPatterns = [
+    /function\s+(\w+)\s*\(/g,
+    /(\w+)\s*[:=]\s*(?:async\s+)?function\s*\(/g,
+    /(\w+)\s*[:=]\s*(?:async\s+)?\([^)]*\)\s*=>/g,
+    /(\w+)\s*[:=]\s*(?:async\s+)?\w+\s*=>/g
+  ];
+
+  let braceDepth = 0;
+  let functionStart = -1;
+  let functionName = '';
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // 检测函数开始
+    for (const pattern of functionPatterns) {
+      pattern.lastIndex = 0;
+      const match = pattern.exec(line);
+      if (match && functionStart === -1) {
+        functionStart = i;
+        functionName = match[1] || 'anonymous';
+      }
+    }
+
+    // 计算大括号深度
+    const openBraces = (line.match(/{/g) || []).length;
+    const closeBraces = (line.match(/}/g) || []).length;
+
+    if (functionStart !== -1) {
+      braceDepth += openBraces - closeBraces;
+
+      if (braceDepth <= 0 && openBraces > 0) {
+        // 函数结束
+        const functionLength = i - functionStart + 1;
+        if (functionLength > maxLines) {
+          issues.push({
+            line: functionStart + 1,
+            message: `函数 '${functionName}' 超过 ${maxLines} 行 (当前 ${functionLength} 行)`,
+            severity: 'warn'
+          });
+        }
+        functionStart = -1;
+        functionName = '';
+        braceDepth = 0;
+      }
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * 检查代码质量
+ */
+function checkQuality(filePath, config) {
+  const issues = [];
+
+  if (!fs.existsSync(filePath)) {
+    return issues;
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n');
+
+  // 1. 检查文件行数
+  if (lines.length > config.maxFileLines) {
+    issues.push({
+      severity: 'error',
+      message: `文件超过 ${config.maxFileLines} 行 (当前 ${lines.length} 行)`
+    });
+  }
+
+  // 2. 检查禁止模式
+  for (const rule of config.forbiddenPatterns) {
+    const pattern = typeof rule.pattern === 'string'
+      ? new RegExp(rule.pattern, 'g')
+      : rule.pattern;
+
+    pattern.lastIndex = 0;
+    const matches = content.match(pattern);
+    if (matches && matches.length > 0) {
+      issues.push({
+        severity: rule.severity || 'warn',
+        message: `${rule.message} (${matches.length} 处)`
+      });
+    }
+  }
+
+  // 3. 检查函数长度（仅对 JS/TS 文件）
+  if (/\.(js|ts|jsx|tsx)$/.test(filePath)) {
+    const longFunctions = detectLongFunctions(content, config.maxFunctionLines);
+    issues.push(...longFunctions);
+  }
+
+  return issues;
+}
+
+/**
+ * 格式化输出
+ */
+function formatOutput(filePath, issues) {
+  if (issues.length === 0) {
+    return null;
+  }
+
+  const errors = issues.filter(i => i.severity === 'error');
+  const warns = issues.filter(i => i.severity === 'warn');
+  const infos = issues.filter(i => i.severity === 'info');
+
+  const relativePath = path.relative(PROJECT_DIR, filePath);
+
+  let output = `\n╔══════════════════════════════════════════════════════════════╗\n`;
+  output += `║  📊 Live Quality Check: ${relativePath.slice(0, 35).padEnd(35)}║\n`;
+  output += `╠══════════════════════════════════════════════════════════════╣\n`;
+
+  if (errors.length > 0) {
+    output += `║  ❌ 错误 (${errors.length}):                                              ║\n`;
+    for (const issue of errors) {
+      output += `║     • ${issue.message.slice(0, 52).padEnd(52)}║\n`;
+    }
+  }
+
+  if (warns.length > 0) {
+    output += `║  ⚠️  警告 (${warns.length}):                                              ║\n`;
+    for (const issue of warns) {
+      output += `║     • ${issue.message.slice(0, 52).padEnd(52)}║\n`;
+    }
+  }
+
+  if (infos.length > 0) {
+    output += `║  ℹ️  信息 (${infos.length}):                                              ║\n`;
+    for (const issue of infos) {
+      output += `║     • ${issue.message.slice(0, 52).padEnd(52)}║\n`;
+    }
+  }
+
+  output += `╚══════════════════════════════════════════════════════════════╝\n`;
+
+  return output;
+}
+
+/**
+ * 从环境变量获取工具输入
+ */
+function getToolInput() {
+  const toolName = process.env.CLAUDE_TOOL_NAME || '';
+  const toolInput = process.env.CLAUDE_TOOL_INPUT || '{}';
+
+  try {
+    const input = JSON.parse(toolInput);
+    return {
+      tool: toolName,
+      filePath: input.file_path || input.path || ''
+    };
+  } catch (e) {
+    return { tool: toolName, filePath: '' };
+  }
+}
+
+/**
+ * 主函数
+ */
+function main() {
+  const { tool, filePath } = getToolInput();
+
+  // 只检查 Write 和 Edit 工具
+  if (!['Write', 'Edit'].includes(tool)) {
+    process.exit(0);
+  }
+
+  // 检查是否豁免
+  if (isExempt(filePath)) {
+    process.exit(0);
+  }
+
+  const config = getConfig();
+  const issues = checkQuality(filePath, config);
+  const output = formatOutput(filePath, issues);
+
+  if (output) {
+    console.log(output);
+  }
+
+  // 始终返回成功（警告不阻止操作）
+  process.exit(0);
+}
+
+main();

package/.claude/hooks/plan-gate.cjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+/**
+ * Plan Gate - 强制规划门控
+ *
+ * PreToolUse 钩子：在任何 Write/Edit 之前检查是否有批准的计划
+ *
+ * 硬阻止模式：无批准计划直接阻止操作
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const HOME_DIR = process.env.HOME || require('os').homedir();
+
+// 检查两个位置的计划目录
+const PLANS_DIRS = [
+  path.join(PROJECT_DIR, '.claude/plans'),    // 项目级计划
+  path.join(HOME_DIR, '.claude/plans')         // 全局计划
+];
+const GATE_CONFIG_FILE = path.join(PROJECT_DIR, '.claude/quality-gate.json');
+
+// 豁免模式：这些文件不需要计划
+const EXEMPT_PATTERNS = [
+  /\.md$/,                    // Markdown 文档
+  /\.json$/,                  // JSON 配置
+  /\.test\./,                 // 测试文件
+  /\.spec\./,                 // 测试文件
+  /__tests__/,                // 测试目录
+  /node_modules/,             // 依赖
+  /\.claude\//,               // Claude 配置
+  /\.git\//,                  // Git 目录
+  /package-lock\.json$/,      // 锁文件
+  /yarn\.lock$/,              // 锁文件
+  /pnpm-lock\.yaml$/,         // 锁文件
+];
+
+/**
+ * 检查文件是否豁免
+ */
+function isExempt(filePath) {
+  if (!filePath) return true;
+  return EXEMPT_PATTERNS.some(pattern => pattern.test(filePath));
+}
+
+/**
+ * 获取配置
+ */
+function getConfig() {
+  try {
+    if (fs.existsSync(GATE_CONFIG_FILE)) {
+      const config = JSON.parse(fs.readFileSync(GATE_CONFIG_FILE, 'utf-8'));
+      return config.planGate || { enabled: true, mode: 'block' };
+    }
+  } catch (e) {
+    // 默认配置
+  }
+  return { enabled: true, mode: 'block' };
+}
+
+/**
+ * 检查是否有批准的计划
+ */
+function hasApprovedPlan() {
+  for (const plansDir of PLANS_DIRS) {
+    // 确保计划目录存在
+    if (!fs.existsSync(plansDir)) {
+      continue;
+    }
+
+    try {
+      const planFiles = fs.readdirSync(plansDir)
+        .filter(f => f.endsWith('.md'));
+
+      for (const planFile of planFiles) {
+        const content = fs.readFileSync(path.join(plansDir, planFile), 'utf-8');
+
+        // 检查计划是否被批准（最近 24 小时内）
+        const stat = fs.statSync(path.join(plansDir, planFile));
+        const ageHours = (Date.now() - stat.mtimeMs) / (1000 * 60 * 60);
+
+        // 只接受 24 小时内的批准计划
+        if (ageHours > 24) {
+          continue;
+        }
+
+        // 检查计划是否被批准
+        if (content.includes('## Approved Plan') ||
+            content.includes('status: approved') ||
+            content.includes('User has approved')) {
+          return true;
+        }
+      }
+    } catch (e) {
+      // 读取失败，继续检查下一个目录
+    }
+  }
+
+  return false;
+}
+
+/**
+ * 从环境变量获取工具输入
+ */
+function getToolInput() {
+  const toolName = process.env.CLAUDE_TOOL_NAME || '';
+  const toolInput = process.env.CLAUDE_TOOL_INPUT || '{}';
+
+  try {
+    const input = JSON.parse(toolInput);
+    return {
+      tool: toolName,
+      filePath: input.file_path || input.path || ''
+    };
+  } catch (e) {
+    return { tool: toolName, filePath: '' };
+  }
+}
+
+/**
+ * 主函数
+ */
+function main() {
+  const config = getConfig();
+
+  // 如果禁用，直接通过
+  if (!config.enabled) {
+    process.exit(0);
+  }
+
+  const { tool, filePath } = getToolInput();
+
+  // 只检查 Write 和 Edit 工具
+  if (!['Write', 'Edit'].includes(tool)) {
+    process.exit(0);
+  }
+
+  // 检查是否豁免
+  if (isExempt(filePath)) {
+    process.exit(0);
+  }
+
+  // 检查是否有批准的计划
+  if (hasApprovedPlan()) {
+    process.exit(0);
+  }
+
+  // 无计划，根据模式处理
+  if (config.mode === 'block') {
+    // 硬阻止：输出错误信息并退出非零状态
+    console.error(`
+╔══════════════════════════════════════════════════════════════╗
+║  ⛔ Plan Gate: 操作被阻止                                     ║
+╠══════════════════════════════════════════════════════════════╣
+║                                                              ║
+║  无批准的实施计划。                                           ║
+║                                                              ║
+║  请先运行:  /plan                                            ║
+║  创建并批准实施计划后再进行代码修改。                          ║
+║                                                              ║
+║  目标文件: ${filePath.slice(0, 45).padEnd(45)}║
+║                                                              ║
+╚══════════════════════════════════════════════════════════════╝
+`);
+    process.exit(1);
+  } else {
+    // 警告模式
+    console.warn(`⚠️  Plan Gate 警告: 建议先运行 /plan 创建实施计划`);
+    process.exit(0);
+  }
+}
+
+main();

package/.claude/hooks/pre-commit.cjs

@@ -66,18 +66,29 @@ async function main() {
     config
   });
 
+  // Use severity from config, default to 'warn' for stricter checking
+  const severity = config.severity || 'warn';
+
   const result = await gate.check({
     files: checkable.map(f => path.join(projectDir, f)),
-    severity: 'error' // Block on errors and critical only
+    severity: severity // Block on configured severity (now 'warn' by default)
   });
 
   if (!result.passed) {
-    console.error('\nPre-commit quality gate failed.');
-    console.error('Fix issues or use --no-verify to bypass (not recommended).\n');
+    console.error('\n╔══════════════════════════════════════════════════════════════╗');
+    console.error('║  ⛔ Pre-commit Quality Gate: 提交被阻止                       ║');
+    console.error('╠══════════════════════════════════════════════════════════════╣');
+    console.error('║                                                              ║');
+    console.error('║  请修复上述问题后重新提交。                                   ║');
+    console.error('║                                                              ║');
+    console.error('║  如确需绕过检查（不推荐）:                                     ║');
+    console.error('║    git commit --no-verify                                    ║');
+    console.error('║                                                              ║');
+    console.error('╚══════════════════════════════════════════════════════════════╝\n');
     process.exit(1);
   }
 
-  console.log('Pre-commit quality checks passed.\n');
+  console.log('\n✅ Pre-commit quality checks passed.\n');
 }
 
 main().catch(err => {

package/.claude/quality-gate.json

@@ -1,6 +1,18 @@
 {
   "enabled": true,
-  "severity": "error",
+  "severity": "warn",
+
+  "planGate": {
+    "enabled": true,
+    "mode": "block",
+    "exempt": [".md", ".json", ".test.", ".spec.", "__tests__", ".claude/"]
+  },
+
+  "liveQuality": {
+    "enabled": true,
+    "maxFileLines": 800,
+    "maxFunctionLines": 50
+  },
   "rules": [
     {
       "id": "line-count-limit",
@@ -46,13 +58,16 @@
     },
     {
       "id": "no-console-logs",
-      "enabled": false,
+      "enabled": true,
       "severity": "warn"
     },
     {
       "id": "function-length",
-      "enabled": false,
-      "severity": "warn"
+      "enabled": true,
+      "severity": "warn",
+      "config": {
+        "maxLines": 50
+      }
     }
   ],
   "gates": {

package/.claude/rules/linus-style.md

@@ -0,0 +1,54 @@
+# Linus 编程哲学
+
+> 审核代码时以此为准则
+
+## 核心原则
+
+| 原则 | 一句话 | 检查方式 |
+|------|--------|----------|
+| **好品味** | 消除特殊情况，而非处理它 | 有 if/else？重新设计数据结构 |
+| **不破坏** | 向后兼容是铁律 | 现有功能全部正常？ |
+| **实用主义** | 解决真问题，拒绝臆想 | 生产环境真的需要？ |
+| **极简** | ≤3 层缩进，函数只做一件事 | 能砍掉一半代码吗？ |
+
+## 思考流程
+
+每次改动前问三个问题：
+
+```
+1. 这是真问题还是臆想？ → 拒绝过度设计
+2. 有更简单的方法吗？   → 永远找最简方案
+3. 会破坏什么吗？       → 列出所有受影响项
+```
+
+## 代码审查输出格式
+
+```
+【品味】🟢好 / 🟡凑合 / 🔴垃圾
+
+【问题】
+- [最糟糕的部分]
+
+【改法】
+- "这个特殊情况可以消除"
+- "10行→3行"
+- "数据结构应该是..."
+```
+
+## 决策标准
+
+**值得做**：
+1. 先简化数据结构
+2. 消除所有特殊情况
+3. 用最笨但最清晰的方式
+4. 零破坏
+
+**不值得做**：
+"这是在解决不存在的问题。真正的问题是 [X]。"
+
+## 代码风格
+
+- 函数：短小，一件事
+- 命名：斯巴达式，直白精准
+- 缩进：≤3 层，否则重构
+- 分支：if/else 是坏味道的信号

package/.claude/settings.json

@@ -51,7 +51,20 @@
       ]
     }
   ],
-  "PreToolUse": [],
+  "PreToolUse": [
+    {
+      "matcher": {
+        "tool_name": "^(Write|Edit)$"
+      },
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/plan-gate.cjs",
+          "timeout": 2000
+        }
+      ]
+    }
+  ],
   "PostToolUse": [
     {
       "matcher": {
@@ -62,6 +75,11 @@
           "type": "command",
           "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/code-formatter.cjs",
           "timeout": 5000
+        },
+        {
+          "type": "command",
+          "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/live-quality.cjs",
+          "timeout": 3000
         }
       ]
     }