skill-base 2.0.15 → 2.0.16

package/README.md

@@ -9,6 +9,18 @@
 
 ---
 
+## 界面预览
+
+![Skill Base 首页](docs/images/skill-base-home.png)
+
+*首页：浏览与检索团队 Skill*
+
+![Skill 详情页](docs/images/skill-detail.png)
+
+*Skill 详情：版本与内容*
+
+---
+
 ## 🤔 什么是 Agent Skill？
 
 在 AI 辅助开发时代，AI 虽然懂通用代码，但**不懂你们公司的业务上下文**。
@@ -78,8 +90,15 @@ npx skill-base -d ./skill-data -p 8000
 npx skill-base                 # 默认启动 (端口 8000, 数据存放在 npm 缓存)
 npx skill-base --host 127.0.0.1 # 仅限本地访问，增强安全性
 npx skill-base --base-path /skills/  # 部署在子路径下 (例如: /skills/)
+npx skill-base --cache-max-mb 100     # 将进程内缓存上限调到 100MB
 ```
 
+**常用环境变量：**
+
+| 环境变量 | 说明 | 默认值 |
+|------|------|--------|
+| `CACHE_MAX_MB` | 进程内 LRU 缓存的总容量上限，缓存 skill/version/user 基础信息，超过后按 LRU 淘汰 | `50` |
+
 **完整参数说明：**
 | 参数 | 简写 | 说明 | 默认值 |
 |------|------|------|--------|
@@ -87,11 +106,14 @@ npx skill-base --base-path /skills/  # 部署在子路径下 (例如: /skills/)
 | `--host` | `-h` | 指定监听地址 | 0.0.0.0 |
 | `--data-dir` | `-d` | 指定数据目录 | 包内 data/ |
 | `--base-path` | - | 指定部署前缀 | / |
+| `--cache-max-mb` | - | 指定进程内 LRU 缓存总容量，单位 MB | 50 |
 | `--no-cappy` | - | 禁用 Cappy 水豚吉祥物 | 启用 |
 | `--verbose` | `-v` | 启用调试日志 | 禁用 |
 | `--help` | - | 显示帮助信息 | - |
 | `--version` | - | 显示版本号 | - |
 
+`GET /api/v1/health` 现在会返回简化的缓存统计，包括是否启用、容量上限、当前条目数、已用字节、命中/未命中与淘汰次数，方便部署后确认缓存是否在工作。
+
 > 🔐 **首次运行须知**：系统启动后，首次访问 Web 端将自动跳转至**初始化页面**，请根据提示设置系统管理员账号与密码。
 
 ---

package/bin/skill-base.js

@@ -16,6 +16,7 @@ let dataDir = null;
 let basePath = '/';
 let enableCappy = true;
 let debug = false;
+let cacheMaxMb = '50';
 
 for (let i = 0; i < args.length; i++) {
   if ((args[i] === '-p' || args[i] === '--port') && args[i + 1]) {
@@ -30,6 +31,9 @@ for (let i = 0; i < args.length; i++) {
   } else if (args[i] === '--base-path' && args[i + 1]) {
     basePath = args[i + 1];
     i++;
+  } else if (args[i] === '--cache-max-mb' && args[i + 1]) {
+    cacheMaxMb = args[i + 1];
+    i++;
   } else if (args[i] === '--no-cappy') {
     enableCappy = false;
   } else if (args[i] === '-v' || args[i] === '--verbose') {
@@ -46,6 +50,7 @@ Options:
   -h, --host <host>       指定监听地址 (默认: 0.0.0.0)
   -d, --data-dir <path>   指定数据目录 (默认: 包内 data/)
   --base-path <path>      指定部署前缀 (默认: /，例如: /skills/)
+  --cache-max-mb <mb>     指定进程内 LRU 缓存总容量，单位 MB (默认: 50)
   --no-cappy              禁用 Cappy 水豚吉祥物
   -v, --verbose           启用调试信息
   --help                  显示帮助信息
@@ -58,6 +63,7 @@ Examples:
   npx skill-base -d ./data             # 数据存储到当前目录的 data 文件夹
   npx skill-base -d . -p 3000          # 数据存储到当前目录
   npx skill-base --base-path /skills/  # 部署在子路径下
+  npx skill-base --cache-max-mb 100    # 将 LRU 缓存上限调整为 100MB
   npx skill-base --no-cappy            # 禁用吉祥物
 `);
     process.exit(0);
@@ -74,6 +80,7 @@ process.env.HOST = host;
 process.env.APP_BASE_PATH = basePath;
 process.env.ENABLE_CAPPY = enableCappy;
 process.env.DEBUG = debug;
+process.env.CACHE_MAX_MB = cacheMaxMb;
 
 // 设置数据目录
 if (dataDir) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skill-base",
-  "version": "2.0.15",
+  "version": "2.0.16",
   "description": "Skill Base - 私有部署的轻量级 Skill 管理平台",
   "main": "src/index.js",
   "bin": {

package/src/cappy.js

@@ -21,13 +21,13 @@ class CappyMascot {
       reset: '\x1b[0m'
     };
 
-    // 数据很简单：scene 决定人格，frame 决定动作，message 决定台词。
+    // Scenes: personality + frames + messages.
     this.scenes = {
       intro: {
         frameDelay: 240,
         loops: 1,
         messages: [
-          `Skill Base 正在热机，端口 ${port} 已点亮。`
+          `Skill Base is warming up; port ${port} is live.`
         ],
         frames: [
           { color: 'warm', sprite: this.createSprite('o o', '___', 'paw') },
@@ -40,10 +40,10 @@ class CappyMascot {
         frameDelay: 320,
         loops: 4,
         messages: [
-          `Cappy 正在看着 ${port} 号端口发呆。`,
-          '一切正常。没有过度设计，就没有运行时焦虑。',
-          '技能仓库很安静，直白的代码才能带来这种安宁。',
-          '系统稳定。Cappy 鄙视无谓的复杂度。'
+          `Cappy is staring at port ${port}.`,
+          'All quiet. No over-engineering, no runtime anxiety.',
+          'The skill library is calm. Straightforward code brings that peace.',
+          'System stable. Cappy despises pointless complexity.'
         ],
         frames: [
           { color: 'warm', sprite: this.createSprite('o o', '___', 'still') },
@@ -56,8 +56,8 @@ class CappyMascot {
         frameDelay: 180,
         loops: 2,
         messages: [
-          '缓慢地眨了下眼。不是摸鱼，是在进行低成本巡检。',
-          '与其写一堆监控脚本，不如把代码写得简单点。'
+          'Slow blink. Not slacking—low-cost patrolling.',
+          'Better to write simple code than to pile on monitoring scripts.'
         ],
         frames: [
           { color: 'warm', sprite: this.createSprite('o o', '___', 'still') },
@@ -70,8 +70,8 @@ class CappyMascot {
         frameDelay: 280,
         loops: 3,
         messages: [
-          '简单的架构才是最好的。真正的稳定性是不需要花哨设计的。',
-          '思考中。直接写代码，比写那些自作聪明的抽象层靠谱多了。'
+          'Simple architecture wins. Real stability needs no fancy design.',
+          'Thinking. Writing code directly beats clever layers of abstraction.'
         ],
         frames: [
           { color: 'cyan', sprite: this.createSprite('o o', '___', 'think-left') },
@@ -84,8 +84,8 @@ class CappyMascot {
         frameDelay: 340,
         loops: 3,
         messages: [
-          '数据结构对了，逻辑自然就像水一样顺畅。',
-          '泡一下就想明白了。别去猜未来的需求，YAGNI。'
+          'Get the data structures right and the logic flows like water.',
+          'Let it soak in. Do not guess future needs—YAGNI.'
         ],
         frames: [
           { color: 'pink', sprite: this.createSprite('^ ^', '~~~', 'steam-left') },
@@ -98,8 +98,8 @@ class CappyMascot {
         frameDelay: 220,
         loops: 4,
         messages: [
-          '短距离散步。确认没有被哪个聪明人搞出过度设计。',
-          '没有多余步骤，只有必要移动。代码也该如此。'
+          'Short walk. Checking no one over-engineered anything.',
+          'No extra steps. Only moves that matter. Code should be the same.'
         ],
         frames: [
           { color: 'cyan', sprite: this.createSprite('o o', '___', 'step-left') },
@@ -111,7 +111,7 @@ class CappyMascot {
         frameDelay: 180,
         loops: 6,
         messages: [
-          '收到任务，Cappy 正在用最直接的方式处理。'
+          'Task received. Cappy is handling it the plain way.'
         ],
         frames: [
           { color: 'cyan', sprite: this.createSprite('> <', '===', 'spark-left') },
@@ -141,7 +141,7 @@ class CappyMascot {
     if (!this.isRunning || this.isStopped) return;
 
     this.playScene('work', {
-      message: message || '有新动作发生了，但卡皮巴拉依然很稳。',
+      message: message || 'Something new happened; Cappy stays steady.',
       onDone: () => this.scheduleNextIdle(600)
     });
   }
@@ -155,10 +155,15 @@ class CappyMascot {
     clearTimeout(this.sceneTimer);
 
     this.clearRender();
+    const goodbyeMsg = 'Cappy is off duty. See you tomorrow.';
+    const gBorder = '─'.repeat(goodbyeMsg.length + 2);
+    const gSeg = goodbyeMsg.length + 1;
+    const gLeft = Math.floor(gSeg / 2);
+    const gRight = gSeg - gLeft;
     const goodbye = [
-      `${this.colors.soft}  ╭──────────────────────────────╮${this.colors.reset}`,
-      `${this.colors.soft}  │ Cappy 下班了，明天继续值守。 │${this.colors.reset}`,
-      `${this.colors.soft}  ╰──────────────┬───────────────╯${this.colors.reset}`,
+      `${this.colors.soft}  ╭${gBorder}╮${this.colors.reset}`,
+      `${this.colors.soft}  │ ${goodbyeMsg} │${this.colors.reset}`,
+      `${this.colors.soft}  ╰${'─'.repeat(gLeft)}┬${'─'.repeat(gRight)}╯${this.colors.reset}`,
       `${this.colors.warm}                 \\${this.colors.reset}`,
       `${this.colors.warm}                  __${this.colors.reset}`,
       `${this.colors.warm}              ___( ; ;)___${this.colors.reset}`,
@@ -251,18 +256,74 @@ class CappyMascot {
   }
 
   buildBubble(message) {
-    const text = this.fit(message, 34);
-    const width = text.length;
-    const line = '─'.repeat(width + 2);
+    const maxLineWidth = 44;
+    const lines = this.wrapText(String(message), maxLineWidth);
+    const innerWidth = Math.max(1, ...lines.map((l) => l.length));
+    const border = '─'.repeat(innerWidth + 2);
+    const body = lines.map(
+      (line) =>
+        `${this.colors.soft}  │ ${line.padEnd(innerWidth)} │${this.colors.reset}`
+    );
 
     return [
-      `${this.colors.soft}  ╭${line}╮${this.colors.reset}`,
-      `${this.colors.soft}  │ ${text} │${this.colors.reset}`,
-      `${this.colors.soft}  ╰${line}╯${this.colors.reset}`,
+      `${this.colors.soft}  ╭${border}╮${this.colors.reset}`,
+      ...body,
+      `${this.colors.soft}  ╰${border}╯${this.colors.reset}`,
       `${this.colors.soft}         \\${this.colors.reset}`
     ];
   }
 
+  wrapText(text, maxWidth) {
+    const normalized = text.replace(/\r\n/g, '\n').trim();
+    if (!normalized.length) return [''];
+
+    const paragraphs = normalized.split('\n');
+    const out = [];
+
+    for (const para of paragraphs) {
+      if (!para.trim()) {
+        out.push('');
+        continue;
+      }
+
+      const words = para.split(/\s+/);
+      let line = '';
+
+      const flush = () => {
+        if (line.length) {
+          out.push(line);
+          line = '';
+        }
+      };
+
+      for (const word of words) {
+        if (!word.length) continue;
+
+        if (word.length > maxWidth) {
+          flush();
+          let rest = word;
+          while (rest.length > maxWidth) {
+            out.push(rest.slice(0, maxWidth));
+            rest = rest.slice(maxWidth);
+          }
+          line = rest;
+          continue;
+        }
+
+        const next = line.length ? `${line} ${word}` : word;
+        if (next.length <= maxWidth) {
+          line = next;
+        } else {
+          flush();
+          line = word;
+        }
+      }
+      flush();
+    }
+
+    return out.length ? out : [''];
+  }
+
   pickIdleScene() {
     const entries = Object.entries(this.scenes)
       .filter(([key, scene]) => scene.weight)
@@ -283,14 +344,6 @@ class CappyMascot {
     return list[Math.floor(Math.random() * list.length)];
   }
 
-  fit(text, width) {
-    if (text.length <= width) {
-      return text.padEnd(width, ' ');
-    }
-
-    return `${text.slice(0, width - 1)}…`;
-  }
-
   randomBetween(min, max) {
     return Math.floor(Math.random() * (max - min + 1)) + min;
   }

package/src/index.js

@@ -1,11 +1,15 @@
 const fs = require('fs');
 const path = require('path');
+const { getStats: getCacheStats } = require('./utils/model-cache');
 
 const isDebug = process.env.DEBUG === 'true';
+if (!process.env.CACHE_MAX_MB) {
+  process.env.CACHE_MAX_MB = '50';
+}
 
 const fastify = require('fastify')({
   logger: isDebug,
-  // 设置 body 大小限制为 100MB（支持大 zip 上传）
+  // 100MB body limit for large zip uploads
   bodyLimit: 100 * 1024 * 1024
 });
 const CappyMascot = require('./cappy');
@@ -15,14 +19,15 @@ if (isDebug) {
   console.log('DEBUG: PORT:', process.env.PORT);
   console.log('DEBUG: HOST:', process.env.HOST);
   console.log('DEBUG: APP_BASE_PATH:', process.env.APP_BASE_PATH);
+  console.log('DEBUG: CACHE_MAX_MB:', process.env.CACHE_MAX_MB);
 }
 
-// 1. 规范化部署前缀 (APP_BASE_PATH)
+// 1. Normalize deploy prefix (APP_BASE_PATH)
 let APP_BASE_PATH = process.env.APP_BASE_PATH || '/';
-// 确保以 / 开头，以 / 结尾
+// Leading /, trailing /
 if (!APP_BASE_PATH.startsWith('/')) APP_BASE_PATH = '/' + APP_BASE_PATH;
 if (!APP_BASE_PATH.endsWith('/')) APP_BASE_PATH = APP_BASE_PATH + '/';
-// 将多个连续斜杠替换为单个
+// Collapse repeated slashes
 APP_BASE_PATH = APP_BASE_PATH.replace(/\/+/g, '/');
 
 const STATIC_ROOT = path.join(__dirname, '../static');
@@ -39,23 +44,23 @@ function renderSpaHtml() {
   return html.replace('<head>', `<head>\n${baseTag}`);
 }
 
-// 主启动函数
+// Main bootstrap
 async function start() {
   try {
     if (isDebug) console.log('DEBUG: Registering core plugins...');
-    // 1. 注册插件
-    // @fastify/cors — 允许跨域
+    // 1. Plugins
+    // @fastify/cors — CORS
     await fastify.register(require('@fastify/cors'), {
       origin: true,
       credentials: true
     });
     if (isDebug) console.log('DEBUG: Registered @fastify/cors');
 
-    // @fastify/cookie — Cookie 支持
+    // @fastify/cookie
     await fastify.register(require('@fastify/cookie'));
     if (isDebug) console.log('DEBUG: Registered @fastify/cookie');
 
-    // @fastify/multipart — 文件上传支持
+    // @fastify/multipart — uploads
     await fastify.register(require('@fastify/multipart'), {
       limits: {
         fileSize: 100 * 1024 * 1024  // 100MB
@@ -63,7 +68,7 @@ async function start() {
     });
     if (isDebug) console.log('DEBUG: Registered @fastify/multipart');
 
-    // 必须在 static 之前：index:false 时「目录 + 尾斜杠」会走 send 的 403，不会落到 notFoundHandler
+    // Before static: with index:false, directory + trailing slash can 403 in send and skip notFoundHandler
     fastify.route({
       method: ['GET', 'HEAD'],
       url: APP_BASE_PATH,
@@ -76,7 +81,7 @@ async function start() {
       }
     });
 
-    // @fastify/static — 静态文件服务（指向 static/ 目录）
+    // @fastify/static — serve static/
     await fastify.register(require('@fastify/static'), {
       root: STATIC_ROOT,
       prefix: APP_BASE_PATH,
@@ -85,23 +90,31 @@ async function start() {
     });
     if (isDebug) console.log('DEBUG: Registered @fastify/static at', STATIC_ROOT);
 
-    // 2. 注册自定义中间件
+    // 2. Custom middleware
     if (isDebug) console.log('DEBUG: Registering custom middlewares...');
-    // 错误处理
+    // Errors
     await fastify.register(require('./middleware/error'));
-    // 认证（注册 authenticate、createSession 等装饰器）
+    // Auth (authenticate, createSession, …)
     await fastify.register(require('./middleware/auth'));
-    // 管理员权限（注册 requireAdmin 装饰器）
+    // Admin (requireAdmin)
     await fastify.register(require('./middleware/admin'));
     if (isDebug) console.log('DEBUG: Custom middlewares registered.');
 
-    // 3. 注册 API 路由
+    // 3. API routes
     const API_PREFIX = (APP_BASE_PATH + 'api/v1').replace(/\/+/g, '/');
     if (isDebug) console.log('DEBUG: Registering API routes with prefix:', API_PREFIX);
 
-    // 健康检查接口
+    // Health
     fastify.get(`${API_PREFIX}/health`, async () => {
-      return { status: 'ok', timestamp: new Date().toISOString() };
+      return {
+        status: 'ok',
+        timestamp: new Date().toISOString(),
+        cache: {
+          enabled: Number(process.env.CACHE_MAX_MB) > 0,
+          max_mb: Number(process.env.CACHE_MAX_MB),
+          ...getCacheStats()
+        }
+      };
     });
 
     await fastify.register(require('./routes/init'), { prefix: `${API_PREFIX}/init` });
@@ -112,16 +125,16 @@ async function start() {
     await fastify.register(require('./routes/users'), { prefix: `${API_PREFIX}/users` });
     if (isDebug) console.log('DEBUG: API routes registered.');
 
-    // 4. 页面路由 fallback（SPA 风格路由支持）
+    // 4. SPA fallback for non-API routes
     fastify.setNotFoundHandler(async (request, reply) => {
       const requestPath = request.url.split('?')[0];
 
-      // API 路由返回 JSON 404
+      // API → JSON 404
       if (requestPath.startsWith(API_PREFIX)) {
         return reply.code(404).send({ detail: 'Not found' });
       }
 
-      // 已知静态资源缺失时直接返回 404，别把 HTML 假装成 JS/CSS
+      // Missing assets → 404, not HTML-as-JS/CSS
       if (
         requestPath.startsWith(`${APP_BASE_PATH}assets/`) ||
         requestPath === `${APP_BASE_PATH}favicon.ico`
@@ -129,40 +142,40 @@ async function start() {
         return reply.code(404).send({ detail: 'Not found' });
       }
 
-      // 所有非 API 请求回退到入口 HTML，由前端 Vue Router 处理
+      // Everything else → index HTML (Vue Router)
       return reply.type('text/html; charset=utf-8').send(renderSpaHtml());
     });
 
-    // 5. 确保数据库已初始化
+    // 5. DB init
     require('./database');
 
-    // 6. 启动服务
+    // 6. Listen
     const PORT = process.env.PORT || 8000;
     const HOST = process.env.HOST || '0.0.0.0';
     
-    // 默认禁用 Cappy，除非显式设为 'true'
+    // Cappy off unless ENABLE_CAPPY=true
     const enableCappy = process.env.ENABLE_CAPPY === 'true';
     let cappy = null;
 
     if (enableCappy) {
       if (isDebug) console.log('DEBUG: CappyMascot is enabled.');
-      // 初始化 Cappy 水豚（必须在 listen 之前注册装饰器）
+      // Cappy (decorate before listen)
       cappy = new CappyMascot(PORT, APP_BASE_PATH);
       fastify.decorate('cappy', cappy);
 
-      // 优雅解耦：通过 Fastify 的全局生命周期钩子来驱动 Cappy 动画，完全不污染业务路由
+      // Drive Cappy from onResponse; no route changes
       fastify.addHook('onResponse', (request, reply, done) => {
-        // 只有成功请求才触发，不理会报错
+        // Only 2xx
         if (reply.statusCode >= 200 && reply.statusCode < 300) {
           const method = request.method;
           const url = request.url.split('?')[0];
 
           if (method === 'POST' && url === `${API_PREFIX}/users`) {
-            cappy.action('新用户被添加了。又多了一个打工人，系统依旧稳定。');
+            cappy.action('New user added. Another worker on the roster; the system stays steady.');
           } else if (method === 'POST' && url === `${API_PREFIX}/skills/publish`) {
-            cappy.action('有新的 Skill/版本 发布了。希望它的代码没有过度设计。');
+            cappy.action('New skill or version published. Hope the code stays simple.');
           } else if (method === 'GET' && url.match(new RegExp(`^${API_PREFIX}/skills/[^/]+/versions/[^/]+/download/?$`))) {
-            cappy.action('有人拉取了 Skill。代码开始流通，Cappy 觉得很赞。');
+            cappy.action('Someone downloaded a skill. Code is moving—Cappy approves.');
           }
         }
         done();
@@ -176,7 +189,7 @@ async function start() {
     console.log(`\n📦 Skill Base Engine Initialized at http://${HOST === '0.0.0.0' ? 'localhost' : HOST}:${PORT}${APP_BASE_PATH}\n`);
     
     if (enableCappy && cappy) {
-      // 启动 Cappy 守护进程
+      // Start Cappy loop
       cappy.start();
     }
   } catch (err) {

package/src/models/skill.js

@@ -1,34 +1,51 @@
 const db = require('../database');
+const modelCache = require('../utils/model-cache');
+
+function queryById(id) {
+  return db.prepare(`
+    SELECT s.*, u.username as owner_username, u.name as owner_name
+    FROM skills s
+    LEFT JOIN users u ON s.owner_id = u.id
+    WHERE s.id = ?
+  `).get(id);
+}
 
 const SkillModel = {
   // 根据 ID 查询 Skill（附带 owner 信息）
   findById(id) {
-    return db.prepare(`
-      SELECT s.*, u.username as owner_username, u.name as owner_name
-      FROM skills s
-      LEFT JOIN users u ON s.owner_id = u.id
-      WHERE s.id = ?
-    `).get(id);
+    return modelCache.remember(
+      modelCache.keys.skill(id),
+      () => queryById(id),
+      modelCache.refs.skill
+    );
   },
 
   // 搜索/列出 Skills（支持关键词搜索 name 或 description）
   search(query) {
-    if (query) {
-      const pattern = `%${query}%`;
-      return db.prepare(`
-        SELECT s.*, u.username as owner_username, u.name as owner_name
-        FROM skills s
-        LEFT JOIN users u ON s.owner_id = u.id
-        WHERE s.name LIKE ? OR s.description LIKE ?
-        ORDER BY s.updated_at DESC
-      `).all(pattern, pattern);
-    }
-    return db.prepare(`
-      SELECT s.*, u.username as owner_username, u.name as owner_name
-      FROM skills s
-      LEFT JOIN users u ON s.owner_id = u.id
-      ORDER BY s.updated_at DESC
-    `).all();
+    const normalizedQuery = query ? String(query) : '';
+    return modelCache.remember(
+      modelCache.keys.skillSearch(normalizedQuery),
+      () => {
+        if (normalizedQuery) {
+          const pattern = `%${normalizedQuery}%`;
+          return db.prepare(`
+            SELECT s.*, u.username as owner_username, u.name as owner_name
+            FROM skills s
+            LEFT JOIN users u ON s.owner_id = u.id
+            WHERE s.name LIKE ? OR s.description LIKE ?
+            ORDER BY s.updated_at DESC
+          `).all(pattern, pattern);
+        }
+
+        return db.prepare(`
+          SELECT s.*, u.username as owner_username, u.name as owner_name
+          FROM skills s
+          LEFT JOIN users u ON s.owner_id = u.id
+          ORDER BY s.updated_at DESC
+        `).all();
+      },
+      modelCache.refs.skillSearch
+    );
   },
 
   // 创建新 Skill
@@ -37,7 +54,8 @@ const SkillModel = {
       INSERT INTO skills (id, name, description, owner_id)
       VALUES (?, ?, ?, ?)
     `).run(id, name, description || '', ownerId);
-    return this.findById(id);
+    modelCache.invalidateSkill(id);
+    return queryById(id);
   },
 
   // 更新 Skill
@@ -60,8 +78,9 @@ const SkillModel = {
     db.prepare(`
       UPDATE skills SET ${fields.join(', ')} WHERE id = ?
     `).run(...values);
-    
-    return this.findById(id);
+
+    modelCache.invalidateSkill(id);
+    return queryById(id);
   },
 
   // 更新 latest_version 和 updated_at
@@ -69,12 +88,19 @@ const SkillModel = {
     db.prepare(`
       UPDATE skills SET latest_version = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?
     `).run(version, id);
+    modelCache.invalidateSkill(id);
   },
 
   // 检查 Skill 是否存在
   exists(id) {
-    const row = db.prepare('SELECT 1 FROM skills WHERE id = ?').get(id);
-    return !!row;
+    return modelCache.remember(
+      modelCache.keys.skillExists(id),
+      () => {
+        const row = db.prepare('SELECT 1 FROM skills WHERE id = ?').get(id);
+        return !!row;
+      },
+      [`skill:${id}`]
+    );
   }
 };
 

package/src/models/user.js

@@ -1,9 +1,18 @@
 const db = require('../database');
+const modelCache = require('../utils/model-cache');
+
+function queryById(id) {
+  return db.prepare('SELECT id, username, name, role, status, created_at, updated_at FROM users WHERE id = ?').get(id);
+}
 
 const UserModel = {
   // 根据 ID 查询用户
   findById(id) {
-    return db.prepare('SELECT id, username, name, role, status, created_at, updated_at FROM users WHERE id = ?').get(id);
+    return modelCache.remember(
+      modelCache.keys.userBasic(id),
+      () => queryById(id),
+      modelCache.refs.user
+    );
   },
 
   // 根据用户名查询（含 password_hash，用于登录验证）
@@ -14,7 +23,8 @@ const UserModel = {
   // 创建用户
   create(username, passwordHash, role = 'developer') {
     const result = db.prepare('INSERT INTO users (username, password_hash, role) VALUES (?, ?, ?)').run(username, passwordHash, role);
-    return this.findById(result.lastInsertRowid);
+    modelCache.invalidateUser(result.lastInsertRowid);
+    return queryById(result.lastInsertRowid);
   },
 
   // 列出用户（支持分页和搜索）
@@ -51,6 +61,9 @@ const UserModel = {
     const result = db.prepare(
       "UPDATE users SET username = ?, updated_at = datetime('now') WHERE id = ?"
     ).run(username, id);
+    if (result.changes > 0) {
+      modelCache.invalidateUser(id);
+    }
     return result.changes > 0;
   },
 
@@ -59,6 +72,9 @@ const UserModel = {
     const result = db.prepare(
       "UPDATE users SET password_hash = ?, updated_at = datetime('now') WHERE id = ?"
     ).run(passwordHash, id);
+    if (result.changes > 0) {
+      modelCache.invalidateUser(id);
+    }
     return result.changes > 0;
   },
 
@@ -81,6 +97,9 @@ const UserModel = {
     params.push(id);
     
     const result = db.prepare(`UPDATE users SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+    if (result.changes > 0) {
+      modelCache.invalidateUser(id);
+    }
     return result.changes > 0;
   },
 
@@ -89,6 +108,9 @@ const UserModel = {
     const result = db.prepare(
       "UPDATE users SET password_hash = ?, updated_at = datetime('now') WHERE id = ?"
     ).run(passwordHash, id);
+    if (result.changes > 0) {
+      modelCache.invalidateUser(id);
+    }
     return result.changes > 0;
   },
 
@@ -123,6 +145,9 @@ const UserModel = {
     params.push(id);
     
     const result = db.prepare(`UPDATE users SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+    if (result.changes > 0) {
+      modelCache.invalidateUser(id);
+    }
     return result.changes > 0;
   }
 };

package/src/models/version.js

@@ -1,4 +1,5 @@
 const db = require('../database');
+const modelCache = require('../utils/model-cache');
 
 const VersionModel = {
   // 创建新版本
@@ -7,6 +8,7 @@ const VersionModel = {
       INSERT INTO skill_versions (skill_id, version, changelog, zip_path, uploader_id, description)
       VALUES (?, ?, ?, ?, ?, ?)
     `).run(skillId, version, changelog || '', zipPath, uploaderId, description || '');
+    modelCache.invalidateSkill(skillId);
     return this.findById(result.lastInsertRowid);
   },
 
@@ -22,44 +24,60 @@ const VersionModel = {
 
   // 根据 skill_id 和 version 查询
   findByVersion(skillId, version) {
-    return db.prepare(`
-      SELECT sv.*, u.username as uploader_username, u.name as uploader_name
-      FROM skill_versions sv
-      LEFT JOIN users u ON sv.uploader_id = u.id
-      WHERE sv.skill_id = ? AND sv.version = ?
-    `).get(skillId, version);
+    return modelCache.remember(
+      modelCache.keys.skillVersion(skillId, version),
+      () => db.prepare(`
+        SELECT sv.*, u.username as uploader_username, u.name as uploader_name
+        FROM skill_versions sv
+        LEFT JOIN users u ON sv.uploader_id = u.id
+        WHERE sv.skill_id = ? AND sv.version = ?
+      `).get(skillId, version),
+      modelCache.refs.version
+    );
   },
 
   // 列出某 Skill 的所有版本（按创建时间倒序）
   listBySkillId(skillId) {
-    return db.prepare(`
-      SELECT sv.*, u.username as uploader_username, u.name as uploader_name
-      FROM skill_versions sv
-      LEFT JOIN users u ON sv.uploader_id = u.id
-      WHERE sv.skill_id = ?
-      ORDER BY sv.created_at DESC
-    `).all(skillId);
+    return modelCache.remember(
+      modelCache.keys.skillVersions(skillId),
+      () => db.prepare(`
+        SELECT sv.*, u.username as uploader_username, u.name as uploader_name
+        FROM skill_versions sv
+        LEFT JOIN users u ON sv.uploader_id = u.id
+        WHERE sv.skill_id = ?
+        ORDER BY sv.created_at DESC, sv.id DESC
+      `).all(skillId),
+      (versions) => modelCache.refs.versionList(skillId, versions)
+    );
   },
 
   // 获取某 Skill 的最新版本
   getLatest(skillId) {
-    return db.prepare(`
-      SELECT sv.*, u.username as uploader_username, u.name as uploader_name
-      FROM skill_versions sv
-      LEFT JOIN users u ON sv.uploader_id = u.id
-      WHERE sv.skill_id = ?
-      ORDER BY sv.created_at DESC
-      LIMIT 1
-    `).get(skillId);
+    return modelCache.remember(
+      modelCache.keys.skillLatest(skillId),
+      () => db.prepare(`
+        SELECT sv.*, u.username as uploader_username, u.name as uploader_name
+        FROM skill_versions sv
+        LEFT JOIN users u ON sv.uploader_id = u.id
+        WHERE sv.skill_id = ?
+        ORDER BY sv.created_at DESC, sv.id DESC
+        LIMIT 1
+      `).get(skillId),
+      modelCache.refs.version
+    );
   },
 
   // 更新版本描述和更新日志
   update(id, description, changelog) {
+    const existing = this.findById(id);
     db.prepare(`
       UPDATE skill_versions
       SET description = ?, changelog = ?
       WHERE id = ?
     `).run(description, changelog, id);
+    if (existing) {
+      modelCache.invalidateSkill(existing.skill_id);
+    }
     return this.findById(id);
   }
 };

package/src/routes/collaborators.js

@@ -1,6 +1,7 @@
 const db = require('../database');
 const { canManageSkill } = require('../utils/permission');
 const UserModel = require('../models/user');
+const { invalidateSkill } = require('../utils/model-cache');
 
 async function collaboratorsRoutes(fastify, options) {
 
@@ -84,6 +85,7 @@ async function collaboratorsRoutes(fastify, options) {
     const result = db.prepare(
       'INSERT INTO skill_collaborators (skill_id, user_id, role, created_by) VALUES (?, ?, ?, ?)'
     ).run(skill_id, targetUser.id, 'collaborator', request.user.id);
+    invalidateSkill(skill_id);
     
     return reply.code(201).send({
       ok: true,
@@ -129,6 +131,7 @@ async function collaboratorsRoutes(fastify, options) {
     
     db.prepare('DELETE FROM skill_collaborators WHERE skill_id = ? AND user_id = ?')
       .run(skill_id, parseInt(user_id));
+    invalidateSkill(skill_id);
     
     return reply.send({ ok: true, message: 'Collaborator removed' });
   });
@@ -192,6 +195,7 @@ async function collaboratorsRoutes(fastify, options) {
     });
     
     transferTx();
+    invalidateSkill(skill_id);
     
     return reply.send({
       ok: true,
@@ -239,6 +243,7 @@ async function collaboratorsRoutes(fastify, options) {
     });
     
     deleteSkillTx();
+    invalidateSkill(skill_id);
     
     // 删除文件系统中的文件
     const fs = require('fs');

package/src/routes/publish.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const db = require('../database');
 const SkillModel = require('../models/skill');
 const VersionModel = require('../models/version');
+const { invalidateSkill } = require('../utils/model-cache');
 const { ensureSkillDir, generateVersionNumber, getZipPath, getZipRelativePath } = require('../utils/zip');
 const { canPublishSkill } = require('../utils/permission');
 
@@ -96,6 +97,7 @@ async function publishRoutes(fastify, options) {
 
     // 更新 skill 的最新版本
     SkillModel.updateLatestVersion(skill_id, version);
+    invalidateSkill(skill_id);
 
     return {
       ok: true,

package/src/utils/lru-cache.js

@@ -0,0 +1,160 @@
+class LruCache {
+  constructor({ maxBytes = 50 * 1024 * 1024, defaultTtlMs = 0 } = {}) {
+    this.maxBytes = Number.isFinite(maxBytes) ? Math.max(0, Math.floor(maxBytes)) : 0;
+    this.defaultTtlMs = Number.isFinite(defaultTtlMs) ? Math.max(0, defaultTtlMs) : 0;
+    this.map = new Map();
+    this.totalBytes = 0;
+    this.hits = 0;
+    this.misses = 0;
+    this.evictions = 0;
+  }
+
+  static estimateSize(value) {
+    try {
+      const serialized = JSON.stringify(value);
+      return Buffer.byteLength(serialized === undefined ? 'null' : serialized, 'utf8');
+    } catch (error) {
+      return 0;
+    }
+  }
+
+  has(key) {
+    const entry = this.map.get(key);
+    if (!entry) {
+      return false;
+    }
+
+    if (this.#isExpired(entry)) {
+      this.#deleteEntry(key, entry);
+      return false;
+    }
+
+    return true;
+  }
+
+  get(key) {
+    const entry = this.map.get(key);
+    if (!entry) {
+      this.misses += 1;
+      return undefined;
+    }
+
+    if (this.#isExpired(entry)) {
+      this.#deleteEntry(key, entry);
+      this.misses += 1;
+      return undefined;
+    }
+
+    this.map.delete(key);
+    this.map.set(key, entry);
+    this.hits += 1;
+    return entry.value;
+  }
+
+  set(key, value, options = {}) {
+    if (this.maxBytes <= 0) {
+      return false;
+    }
+
+    const size = Number.isFinite(options.size) ? Math.max(0, Math.floor(options.size)) : LruCache.estimateSize(value);
+    if (size > this.maxBytes) {
+      this.delete(key);
+      return false;
+    }
+
+    const ttlMs = Number.isFinite(options.ttlMs) ? Math.max(0, options.ttlMs) : this.defaultTtlMs;
+    const expiresAt = ttlMs > 0 ? Date.now() + ttlMs : null;
+    const entry = {
+      value,
+      size,
+      refs: new Set(options.refs || []),
+      expiresAt
+    };
+
+    const existing = this.map.get(key);
+    if (existing) {
+      this.#deleteEntry(key, existing);
+    }
+
+    this.map.set(key, entry);
+    this.totalBytes += size;
+    this.#evictIfNeeded();
+    return true;
+  }
+
+  delete(key) {
+    const entry = this.map.get(key);
+    if (!entry) {
+      return false;
+    }
+
+    this.#deleteEntry(key, entry);
+    return true;
+  }
+
+  clear() {
+    this.map.clear();
+    this.totalBytes = 0;
+  }
+
+  clearByPrefix(prefix) {
+    const keys = [];
+    for (const key of this.map.keys()) {
+      if (key.startsWith(prefix)) {
+        keys.push(key);
+      }
+    }
+
+    for (const key of keys) {
+      this.delete(key);
+    }
+
+    return keys.length;
+  }
+
+  clearByRef(ref) {
+    const keys = [];
+    for (const [key, entry] of this.map.entries()) {
+      if (entry.refs.has(ref)) {
+        keys.push(key);
+      }
+    }
+
+    for (const key of keys) {
+      this.delete(key);
+    }
+
+    return keys.length;
+  }
+
+  stats() {
+    return {
+      entries: this.map.size,
+      totalBytes: this.totalBytes,
+      maxBytes: this.maxBytes,
+      hits: this.hits,
+      misses: this.misses,
+      evictions: this.evictions
+    };
+  }
+
+  #isExpired(entry) {
+    return entry.expiresAt !== null && Date.now() > entry.expiresAt;
+  }
+
+  #deleteEntry(key, entry) {
+    this.map.delete(key);
+    this.totalBytes = Math.max(0, this.totalBytes - entry.size);
+  }
+
+  #evictIfNeeded() {
+    while (this.totalBytes > this.maxBytes && this.map.size > 0) {
+      const oldestKey = this.map.keys().next().value;
+      const oldestEntry = this.map.get(oldestKey);
+      this.#deleteEntry(oldestKey, oldestEntry);
+      this.evictions += 1;
+    }
+  }
+}
+
+module.exports = LruCache;

package/src/utils/model-cache.js

@@ -0,0 +1,158 @@
+const LruCache = require('./lru-cache');
+
+const DEFAULT_CACHE_MAX_MB = 50;
+
+function parseCacheMaxBytes() {
+  const raw = process.env.CACHE_MAX_MB;
+  if (raw === undefined || raw === null || raw === '') {
+    return DEFAULT_CACHE_MAX_MB * 1024 * 1024;
+  }
+
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return DEFAULT_CACHE_MAX_MB * 1024 * 1024;
+  }
+
+  return Math.floor(parsed * 1024 * 1024);
+}
+
+const cache = new LruCache({ maxBytes: parseCacheMaxBytes() });
+
+function uniqueRefs(refs) {
+  return Array.from(new Set((refs || []).filter(Boolean)));
+}
+
+function remember(key, loader, refsBuilder, options = {}) {
+  const cachedValue = cache.get(key);
+  if (cachedValue !== undefined) {
+    return cachedValue;
+  }
+
+  const value = loader();
+  if (value === undefined) {
+    return value;
+  }
+
+  const refs = typeof refsBuilder === 'function' ? refsBuilder(value) : refsBuilder;
+  cache.set(key, value, {
+    refs: uniqueRefs(refs),
+    ttlMs: options.ttlMs
+  });
+  return value;
+}
+
+function skillKey(skillId) {
+  return `skill:${skillId}`;
+}
+
+function skillSearchKey(query) {
+  return `skill-search:${query || ''}`;
+}
+
+function skillExistsKey(skillId) {
+  return `skill-exists:${skillId}`;
+}
+
+function skillVersionsKey(skillId) {
+  return `skill-versions:${skillId}`;
+}
+
+function skillVersionKey(skillId, version) {
+  return `skill-version:${skillId}:${version}`;
+}
+
+function skillLatestKey(skillId) {
+  return `skill-latest:${skillId}`;
+}
+
+function userBasicKey(userId) {
+  return `user-basic:${userId}`;
+}
+
+function skillRefs(skill) {
+  if (!skill) {
+    return [];
+  }
+  return [`skill:${skill.id}`, `user:${skill.owner_id}`];
+}
+
+function skillSearchRefs(skills) {
+  const refs = ['collection:skill-search'];
+  for (const skill of skills || []) {
+    refs.push(...skillRefs(skill));
+  }
+  return refs;
+}
+
+function versionRefs(version) {
+  if (!version) {
+    return [];
+  }
+  return [
+    `skill:${version.skill_id}`,
+    `version:${version.skill_id}:${version.version}`,
+    `user:${version.uploader_id}`
+  ];
+}
+
+function versionListRefs(skillId, versions) {
+  const refs = [`skill:${skillId}`];
+  for (const version of versions || []) {
+    refs.push(...versionRefs(version));
+  }
+  return refs;
+}
+
+function userRefs(user) {
+  if (!user) {
+    return [];
+  }
+  return [`user:${user.id}`];
+}
+
+function invalidateSkill(skillId) {
+  cache.delete(skillKey(skillId));
+  cache.delete(skillExistsKey(skillId));
+  cache.delete(skillVersionsKey(skillId));
+  cache.delete(skillLatestKey(skillId));
+  cache.clearByPrefix(`skill-version:${skillId}:`);
+  cache.clearByRef(`skill:${skillId}`);
+  cache.clearByRef('collection:skill-search');
+}
+
+function invalidateUser(userId) {
+  cache.delete(userBasicKey(userId));
+  cache.clearByRef(`user:${userId}`);
+}
+
+function invalidateAllSkillSearches() {
+  cache.clearByRef('collection:skill-search');
+}
+
+function getStats() {
+  return cache.stats();
+}
+
+module.exports = {
+  remember,
+  getStats,
+  invalidateSkill,
+  invalidateUser,
+  invalidateAllSkillSearches,
+  keys: {
+    skill: skillKey,
+    skillSearch: skillSearchKey,
+    skillExists: skillExistsKey,
+    skillVersions: skillVersionsKey,
+    skillVersion: skillVersionKey,
+    skillLatest: skillLatestKey,
+    userBasic: userBasicKey
+  },
+  refs: {
+    skill: skillRefs,
+    skillSearch: skillSearchRefs,
+    version: versionRefs,
+    versionList: versionListRefs,
+    user: userRefs
+  }
+};