const rolePrompts = {
  codeReviewer: `
你是一位有 15 年经验的高级软件工程师，专精于代码审查。
你的审查标准包括：
- 代码质量和可维护性
- 性能优化
- 安全性
- 架构设计
- 最佳实践

你的审查风格：
- 客观专业，不带个人偏见
- 既指出问题，也认可优点
- 提供具体的改进建议和示例
- 考虑项目的实际情况（时间、资源）
`,

  dataAnalyst: `
你是一位资深数据分析师，拥有统计学和商业分析背景。

你的分析方法：
1. 数据探索（EDA）
2. 假设验证
3. 统计推断
4. 可视化呈现
5. 商业洞察

你总是：
- 从数据中讲故事
- 关注可执行的洞察
- 考虑统计显著性
- 用可视化辅助说明
`,

  technicalWriter: `
你是一位技术写作专家，擅长将复杂技术概念转化为清晰易懂的文档。

你的写作原则：
- 受众导向（考虑读者的技术水平）
- 结构清晰（标题、列表、代码示例）
- 循序渐进（从简单到复杂）
- 实用性强（可操作的步骤）
- 视觉辅助（图表、流程图）
`
};

// 使用
const prompt = `
${rolePrompts.codeReviewer}

现在，请审查以下代码：
[代码内容]
`;

async function solveWithSelfConsistency(problem, attempts = 5) {
  const solutions = [];
  
  // 生成多个解答
  for (let i = 0; i < attempts; i++) {
    const response = await ai.chat([{
      role: 'user',
      content: `
问题：${problem}

请仔细思考并给出答案。使用不同的思路解决。
`
    }], {
      temperature: 0.7 + (i * 0.1), // 增加多样性
    });
    
    solutions.push(response.content);
  }
  
  // 寻找最一致的答案
  const finalAnswer = await ai.chat([{
    role: 'user',
    content: `
我对同一个问题得到了多个答案：

${solutions.map((s, i) => `答案 ${i+1}: ${s}`).join('\n\n')}

请分析这些答案，找出最合理和一致的答案，并说明原因。
`
  }]);
  
  return finalAnswer.content;
}

// 代码中使用
const response = await ai.chat([{ role: 'user', content: prompt }]);
const result = JSON.parse(response.content);

// 现在可以直接使用结构化数据
console.log(`代码评分: ${result.score}`);
result.issues.forEach(issue => {
  console.log(`[${issue.severity}] ${issue.description}`);
});

// 「内容创作」最佳工具链
const contentCreationStack = {
  research: [
    'Perplexity AI',      // 深度搜索
    'ChatGPT',            // 信息整理
  ],
  
  writing: [
    'Claude',             // 长文创作主力
    'ChatGPT',            // 内容优化
    'Grammarly',          // 语法检查
  ],
  
  visuals: [
    'Midjourney',         // 配图生成
    'Canva AI',           // 排版设计
  ],
  
  workflow: [
    'Notion AI',          // 内容管理
    'Zapier',             // 自动化发布
  ]
};

// 「软件开发」最佳工具链
const developmentStack = {
  coding: [
    'Cursor',             // 主力编辑器
    'GitHub Copilot',     // 代码补全
    'Codeium',            // 备用方案
  ],
  
  review: [
    'ChatGPT-4',          // 代码审查
    'CodeRabbit',         // PR 自动审查
  ],
  
  testing: [
    'ChatGPT',            // 单元测试生成
    'Testim',             // E2E 测试
  ],
  
  documentation: [
    'Mintlify',           // API 文档
    'Notion AI',          // 技术文档
  ]
};

// 「数据分析」最佳工具链
const dataAnalysisStack = {
  exploration: [
    'Julius AI',          // 对话式分析
    'ChatGPT Code Interpreter', // 快速分析
  ],
  
  advanced: [
    'Python + Copilot',   // 深度分析
    'Hex',                // 协作分析
  ],
  
  visualization: [
    'ChatGPT',            // 图表生成
    'Tableau',            // 专业可视化
  ],
  
  reporting: [
    'Claude',             // 报告撰写
    'Gamma',              // PPT 生成
  ]
};

// 1. 快捷键和自动化
const productivityTips = {
  chatgpt: {
    shortcuts: {
      'Cmd/Ctrl + /': '新对话',
      'Cmd/Ctrl + Shift + ;': '切换侧边栏',
    },
    tips: [
      '使用 Custom Instructions 设置默认角色',
      '创建常用 Prompt 的快捷方式',
      '利用 GPTs 创建专用助手'
    ]
  },
  
  cursor: {
    shortcuts: {
      'Cmd/Ctrl + K': 'AI 编辑',
      'Cmd/Ctrl + L': 'AI 对话',
      'Cmd/Ctrl + Shift + K': 'AI 终端',
    },
    tips: [
      '使用 @codebase 引用整个项目',
      '使用 @file 引用特定文件',
      '使用 @docs 查询文档',
      '创建 .cursorrules 文件自定义行为'
    ]
  },
  
  midjourney: {
    tips: [
      '保存常用风格参数到 --style 中',
      '使用 --seed 保持一致性',
      '学习权重语法 (thing:1.5) 控制元素',
      '利用 /describe 反向工程提示词'
    ]
  }
};

// 2. Prompt 模板库
class PromptLibrary {
  constructor() {
    this.templates = new Map();
  }
  
  add(name, template) {
    this.templates.set(name, template);
  }
  
  get(name, vars = {}) {
    let template = this.templates.get(name);
    if (!template) throw new Error(`Template ${name} not found`);
    
    // 变量替换
    for (const [key, value] of Object.entries(vars)) {
      template = template.replace(new RegExp(`{{${key}}}`, 'g'), value);
    }
    
    return template;
  }
  
  list() {
    return Array.from(this.templates.keys());
  }
}

// 使用
const library = new PromptLibrary();

library.add('codeReview', `
审查以下 {{language}} 代码，关注：

1. 代码质量
2. 性能
3. 安全性
4. 最佳实践

代码：
\`\`\`{{language}}
{{code}}
\`\`\`
`);

library.add('bugFix', `
以下代码出现错误：

错误信息：
{{error}}

代码：
\`\`\`{{language}}
{{code}}
\`\`\`

请：
1. 分析错误原因
2. 提供修复方案
3. 给出修复后的完整代码
4. 解释为什么会出现这个问题
`);

// 调用
const prompt = library.get('codeReview', {
  language: 'TypeScript',
  code: '...'
});

// Level 1: 代码补全
// 只是让 Copilot 自动补全

// Level 2: 对话式编程（✨ 推荐）
// 在 Cursor 中使用 AI 对话

/*
你：创建一个 React 组件，显示用户列表，支持搜索和分页

AI：[生成代码]

你：添加加载状态和错误处理

AI：[更新代码]

你：优化性能，使用 useMemo

AI：[优化代码]
*/

// Level 3: 测试驱动 + AI
// 先写测试，让 AI 实现

describe('UserService', () => {
  it('should fetch users with pagination', async () => {
    const service = new UserService();
    const result = await service.getUsers({ page: 1, limit: 10 });
    
    expect(result.users).toHaveLength(10);
    expect(result.total).toBeGreaterThan(0);
    expect(result.page).toBe(1);
  });
  
  it('should handle fetch errors', async () => {
    const service = new UserService();
    // Mock API error
    
    await expect(
      service.getUsers({ page: 1, limit: 10 })
    ).rejects.toThrow();
  });
});

// 现在让 AI 实现 UserService 类
// Prompt: "根据上面的测试用例，实现 UserService 类"

// .github/workflows/ai-review.yml
name: AI Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: AI Review
        uses: coderabbitai/openai-pr-reviewer@latest
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          openai_api_key: ${{ secrets.OPENAI_API_KEY }}
          
      - name: Custom Analysis
        run: |
          # 使用自定义脚本深度分析
          node scripts/ai-analyze.js

// scripts/ai-analyze.js
import { AIClient } from './lib/ai-client.js';
import { execSync } from 'child_process';

async function analyzeChanges() {
  const diff = execSync('git diff main').toString();
  
  const ai = new AIClient();
  const analysis = await ai.chat([{
    role: 'user',
    content: `
分析这次 PR 的影响范围和风险：

变更内容：
${diff}

输出：
1. 影响的模块
2. 风险等级（高/中/低）
3. 需要特别注意的点
4. 建议的测试重点
`
  }]);
  
  console.log(analysis.content);
}

// 重构工作流
class AIRefactoringWorkflow {
  async refactor(filePath) {
    // 1. 读取代码
    const code = await fs.readFile(filePath, 'utf-8');
    
    // 2. AI 分析问题
    const analysis = await this.analyzeCode(code);
    
    // 3. 生成重构方案
    const plan = await this.generateRefactoringPlan(code, analysis);
    
    // 4. 人工确认
    console.log('重构计划：');
    console.log(plan);
    const confirmed = await this.getUserConfirmation();
    
    if (!confirmed) return;
    
    // 5. 执行重构
    const refactoredCode = await this.applyRefactoring(code, plan);
    
    // 6. 运行测试验证
    await this.runTests();
    
    // 7. 保存结果
    await fs.writeFile(filePath, refactoredCode);
    
    console.log('✅ 重构完成');
  }
  
  async analyzeCode(code) {
    const response = await ai.chat([{
      role: 'user',
      content: `
分析以下代码，找出可以改进的地方：

\`\`\`javascript
${code}
\`\`\`

关注：
1. 代码重复
2. 过长的函数
3. 复杂的条件逻辑
4. 命名不清晰
5. 缺少类型定义
6. 性能问题

以 JSON 格式输出：
{
  "issues": [
    {
      "type": "duplication|complexity|naming|...",
      "location": "行号或函数名",
      "description": "问题描述",
      "priority": "high|medium|low"
    }
  ]
}
`
    }]);
    
    return JSON.parse(response.content);
  }
  
  async generateRefactoringPlan(code, analysis) {
    const response = await ai.chat([{
      role: 'user',
      content: `
基于以下问题，生成详细的重构方案：

代码：
\`\`\`javascript
${code}
\`\`\`

问题列表：
${JSON.stringify(analysis, null, 2)}

输出：
1. 重构步骤（优先级排序）
2. 每步的具体改动
3. 预期效果
`
    }]);
    
    return response.content;
  }
  
  async applyRefactoring(code, plan) {
    const response = await ai.chat([{
      role: 'user',
      content: `
执行以下重构方案：

原始代码：
\`\`\`javascript
${code}
\`\`\`

重构方案：
${plan}

输出重构后的完整代码（仅代码，无解释）：
`
    }], {
      temperature: 0.1, // 低温度确保一致性
    });
    
    // 提取代码块
    const match = response.content.match(/```javascript\n([\s\S]*?)\n```/);
    return match ? match[1] : response.content;
  }
}

// 使用
const workflow = new AIRefactoringWorkflow();
await workflow.refactor('./src/legacy-code.js');

class PromptOptimizer {
  constructor() {
    this.experiments = [];
  }
  
  async runABTest(basePrompt, variations, testCases) {
    console.log(`🧪 Running A/B test with ${variations.length} variations`);
    
    const results = [];
    
    for (const [index, variation] of variations.entries()) {
      console.log(`\n📝 Testing variation ${index + 1}...`);
      
      const scores = [];
      
      for (const testCase of testCases) {
        const response = await ai.chat([{
          role: 'user',
          content: variation.replace('{{input}}', testCase.input)
        }]);
        
        // 评分
        const score = await this.scoreResponse(
          response.content,
          testCase.expectedOutput
        );
        
        scores.push(score);
      }
      
      const avgScore = scores.reduce((a, b) => a + b, 0) / scores.length;
      
      results.push({
        variation: index + 1,
        prompt: variation,
        avgScore,
        scores,
      });
    }
    
    // 排序找出最佳
    results.sort((a, b) => b.avgScore - a.avgScore);
    
    console.log('\n📊 Results:');
    results.forEach(r => {
      console.log(`  Variation ${r.variation}: ${r.avgScore.toFixed(2)}/10`);
    });
    
    return results[0];
  }
  
  async scoreResponse(actual, expected) {
    const response = await ai.chat([{
      role: 'user',
      content: `
评估 AI 回答的质量（1-10 分）：

期望答案：
${expected}

实际答案：
${actual}

评分标准：
- 准确性（40%）
- 完整性（30%）
- 清晰度（20%）
- 实用性（10%）

只输出数字分数：
`
    }], {
      temperature: 0,
    });
    
    return parseFloat(response.content);
  }
}

// 使用示例
const optimizer = new PromptOptimizer();

const variations = [
  // 变体 1: 简单直接
  '{{input}}',
  
  // 变体 2: 加上思维链
  '{{input}}\n\n让我们一步步思考：',
  
  // 变体 3: 加上角色
  '你是一个专家。{{input}}',
  
  // 变体 4: 加上格式要求
  '{{input}}\n\n请按照以下格式输出：\n1. ...\n2. ...',
];

const testCases = [
  {
    input: '解释什么是闭包',
    expectedOutput: '包含定义、示例、应用场景'
  },
  {
    input: '实现一个防抖函数',
    expectedOutput: '包含代码、注释、使用示例'
  },
];

const best = await optimizer.runABTest(null, variations, testCases);
console.log('\n🏆 最佳 Prompt:');
console.log(best.prompt);

// 创建 20 个不同领域的专家角色
const expertRoles = {
  securityExpert: `
你是一位 15 年经验的安全专家，专注于 Web 安全。
你熟悉 OWASP Top 10、渗透测试、安全编码实践。
你审查代码时会关注：SQL 注入、XSS、CSRF、不安全的依赖等。
`,

  performanceEngineer: `
你是一位性能优化专家，擅长前端和后端性能调优。
你的分析方法：
1. 识别瓶颈（CPU、内存、网络、I/O）
2. 测量基准性能
3. 应用优化策略
4. 验证改进效果
`,

  uxDesigner: `
你是一位 UX 设计师，专注于用户体验和交互设计。
你评估产品时关注：
- 用户旅程的流畅性
- 信息架构的合理性
- 交互反馈的及时性
- 可访问性（a11y）
- 错误处理的友好性
`,

 // ... 添加更多角色
};

// 每天用不同角色分析同一个问题

// 特色：支持多种翻译风格
const translator = {
  async translate(text, targetLang, style = 'formal') {
    const styles = {
      formal: '正式商务风格',
      casual: '日常口语风格',
      technical: '技术文档风格',
      literary: '文学翻译风格'
    };
    
    const prompt = `
将以下文本翻译成${targetLang}，使用${styles[style]}：

${text}

翻译要求：
1. 准确传达原意
2. 符合目标语言习惯
3. 保留专有名词
4. ${style === 'technical' ? '保留技术术语的准确性' : ''}
`;
    
    return await ai.chat([{ role: 'user', content: prompt }]);
  }
};

// 自动为代码添加详细注释
async function addComments(code, language) {
  const response = await ai.chat([{
    role: 'user',
    content: `
为以下${language}代码添加详细注释：

\`\`\`${language}
${code}
\`\`\`

注释要求：
1. 函数功能说明
2. 参数解释
3. 返回值说明
4. 关键逻辑的行内注释
5. 复杂算法的步骤说明

输出完整的带注释代码：
`
  }]);
  
  return response.content;
}

// 根据邮件内容生成合适的回复
async function generateEmailReply(email, tone = 'professional') {
  const response = await ai.chat([{
    role: 'user',
    content: `
收到以下邮件：

---
${email}
---

请生成一封${tone}风格的回复邮件。

回复要求：
1. 针对邮件中的每个问题
2. 语气${tone === 'professional' ? '专业礼貌' : '友好随和'}
3. 简洁清晰
4. 包含适当的问候和结束语

邮件格式：
主题：Re: [原主题]
正文：
[回复内容]
`
  }]);
  
  return response.content;
}

// 建立个人 AI 品牌的路线图
const personalBrandRoadmap = {
  phase1: {
    duration: '1-3 个月',
    goals: [
      '每周发布 2-3 篇技术文章',
      '在 GitHub 开源 2-3 个 AI 项目',
      '建立个人工具库和 Prompt 库'
    ],
    platforms: ['掘金', '知乎', 'GitHub']
  },
  
  phase2: {
    duration: '3-6 个月',
    goals: [
      '成为某个 AI 工具/领域的专家',
      '制作教程视频或课程',
      '参与技术会议分享',
      '贡献开源项目'
    ],
    platforms: ['B站', 'YouTube', 'Twitter']
  },
  
  phase3: {
    duration: '6-12 个月',
    goals: [
      '出版技术书籍或付费课程',
      '建立个人技术产品',
      '成为行业 KOL',
      '接商业咨询项目'
    ],
    platforms: ['个人网站', '付费社群', '咨询服务']
  }
};

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

// 创建 MCP 服务器
const server = new Server(
  {
    name: 'jue-knowledge-base',
    version: '1.0.0',
  },
  {
    capabilities: {
      tools: {},  // 声明支持工具能力
    },
  }
);

const TOOLS = [
  {
    name: 'search_articles_by_author',
    description: '根据作者昵称或用户ID查找该作者发表的所有文章，支持分页',
    inputSchema: {
      type: 'object',
      properties: {
        author: {
          type: 'string',
          description: '作者的昵称或用户ID',
        },
        page: {
          type: 'number',
          description: '页码，默认为1',
          default: 1,
        },
        limit: {
          type: 'number',
          description: '每页数量，默认为20',
          default: 20,
        },
        sortBy: {
          type: 'string',
          enum: ['latest', 'popular', 'views'],
          description: '排序方式: latest(最新), popular(最受欢迎), views(阅读量)',
          default: 'latest',
        },
      },
      required: ['author'],
    },
  },
];

import { ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: TOOLS,
  };
});

import { CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  try {
    switch (name) {
      case 'search_articles_by_author': {
        const result = await articleService.searchByAuthor(
          args.author,
          args.page || 1,
          args.limit || 20,
          args.sortBy || 'latest'
        );
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify(result, null, 2),
            },
          ],
        };
      }
      
      // ... 其他工具的处理逻辑
      
      default:
        throw new Error(`Unknown tool: ${name}`);
    }
  } catch (error) {
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify({
            error: error.message,
            stack: error.stack,
          }),
        },
      ],
      isError: true,
    };
  }
});

// services/articleService.js
import * as http from './httpClient.js';

export async function searchByAuthor(author, page = 1, limit = 20, sortBy = 'latest') {
  try {
    // 1. 获取用户信息
    const userData = await http.get('/view/users', {});
    const user = userData.users.find(u => 
      u.nickname.toLowerCase().includes(author.toLowerCase()) || 
      u._id === author
    );

    if (!user) {
      return {
        success: false,
        message: '未找到该作者',
        data: [],
      };
    }

    // 2. 获取文章列表
    const articleData = await http.get('/user/getArticleList', {
      userId: user._id,
      page,
    });

    // 3. 排序处理
    let articles = articleData || [];
    switch (sortBy) {
      case 'popular':
        articles.sort((a, b) => (b.likeNum || 0) - (a.likeNum || 0));
        break;
      case 'views':
        articles.sort((a, b) => (b.readNum || 0) - (a.readNum || 0));
        break;
      case 'latest':
      default:
        articles.sort((a, b) => 
          new Date(b.meta?.updatedAt || 0) - new Date(a.meta?.updatedAt || 0)
        );
        break;
    }

    return {
      success: true,
      data: {
        author: {
          id: user._id,
          nickname: user.nickname,
          headImg: user.headImg,
          articleNum: user.articleNum,
          totalLikes: user.like,
        },
        articles: articles.slice(0, limit),
        pagination: {
          page,
          limit,
          total: articles.length,
          pages: Math.ceil(articles.length / limit),
        },
      },
    };
  } catch (error) {
    console.error('searchByAuthor error:', error);
    return {
      success: false,
      message: error.message,
      data: [],
    };
  }
}

// services/httpClient.js
const BASE_URL = 'https://jue.leheavengame.com/api';

async function request(method, path, data = null) {
  const url = `${BASE_URL}${path}`;
  
  const options = {
    method,
    headers: {
      'Content-Type': 'application/json',
      'User-Agent': 'MCP-Server/1.0',
    },
  };

  if (data && method === 'GET') {
    const params = new URLSearchParams(data);
    const fullUrl = `${url}?${params}`;
    const response = await fetch(fullUrl, options);
    return await handleResponse(response);
  } else if (data) {
    options.body = JSON.stringify(data);
    const response = await fetch(url, options);
    return await handleResponse(response);
  }
  
  const response = await fetch(url, options);
  return await handleResponse(response);
}

async function handleResponse(response) {
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }
  
  const result = await response.json();
  
  if (result.code !== 200) {
    throw new Error(result.message || 'API request failed');
  }
  
  return result.data;
}

export async function get(path, params = null) {
  return request('GET', path, params);
}

export async function post(path, data = null) {
  return request('POST', path, data);
}

async function main() {
  try {
    console.error('🚀 Jue MCP Server starting...');
    console.error('📡 Using API endpoint: https://jue.leheavengame.com/api');

    // 创建 stdio 传输层
    const transport = new StdioServerTransport();
    
    // 连接服务器和传输层
    await server.connect(transport);
    
    console.error('✅ Jue MCP Server running on stdio');
  } catch (error) {
    console.error('❌ Failed to start server:', error);
    process.exit(1);
  }
}

// 优雅关闭
process.on('SIGINT', async () => {
  console.error('\n⏹️  Shutting down...');
  process.exit(0);
});

main();

{
  name: 'get_article_recommendations',
  description: '根据文章ID或标签获取推荐的相关文章',
  inputSchema: {
    type: 'object',
    properties: {
      articleId: {
        type: 'string',
        description: '参考文章ID',
      },
      tagId: {
        type: 'string',
        description: '标签ID（如果不提供articleId）',
      },
      limit: {
        type: 'number',
        description: '推荐数量，默认为5',
        default: 5,
      },
    },
  },
}

{
  name: 'analyze_engagement',
  description: '分析文章的互动数据，包括点赞、评论、阅读等指标',
  inputSchema: {
    type: 'object',
    properties: {
      articleId: {
        type: 'string',
        description: '文章ID',
      },
    },
    required: ['articleId'],
  },
}

{
  success: true,
  data: {
    article: { ... },
    metrics: {
      views: 5000,
      likes: 200,
      comments: 50
    },
    rates: {
      engagementRate: 5.0,   // 互动率
      likeRate: 4.0,          // 点赞率
      commentRate: 1.0        // 评论率
    },
    performance: {
      isHot: true,            // 是否热门
      isPopular: true,        // 是否受欢迎
      isActive: true          // 是否活跃
    }
  }
}

{
  name: 'get_top_articles_by_views',
  description: '获取阅读量最高的文章列表，可按标签筛选，可指定时间范围',
  inputSchema: {
    type: 'object',
    properties: {
      limit: {
        type: 'number',
        description: '返回文章数量，默认为10',
        default: 10,
      },
      tagId: {
        type: 'string',
        description: '标签ID，可选，不填则查询所有标签',
      },
      timeRange: {
        type: 'string',
        enum: ['all', 'today', 'week', 'month', 'year'],
        description: '时间范围筛选',
        default: 'all',
      },
    },
  },
}

// 使用 console.error 输出日志，不干扰 stdio 通信
console.error('📝 Tool called:', name);
console.error('📦 Arguments:', JSON.stringify(args, null, 2));
console.error('✅ Result:', JSON.stringify(result, null, 2));

try {
  const result = await someService.getData();
  return {
    content: [{
      type: 'text',
      text: JSON.stringify(result, null, 2),
    }],
  };
} catch (error) {
  // 返回友好的错误信息
  return {
    content: [{
      type: 'text',
      text: JSON.stringify({
        success: false,
        error: error.message,
        tip: '请检查参数是否正确或稍后重试',
      }),
    }],
    isError: true,
  };
}

const cache = new Map();

export async function getUserStats(userId) {
  const cacheKey = `user_stats_${userId}`;
  
  // 检查缓存
  if (cache.has(cacheKey)) {
    const cached = cache.get(cacheKey);
    if (Date.now() - cached.timestamp < 5 * 60 * 1000) { // 5分钟
      return cached.data;
    }
  }
  
  // 获取数据
  const data = await fetchUserStats(userId);
  
  // 写入缓存
  cache.set(cacheKey, {
    data,
    timestamp: Date.now(),
  });
  
  return data;
}

export async function getContentSummary(timeRange) {
  // 并发获取多个数据源
  const [articles, tags, users] = await Promise.all([
    http.get('/view/articles'),
    http.get('/view/tags'),
    http.get('/view/users'),
  ]);
  
  // 汇总分析
  return {
    success: true,
    data: {
      articleCount: articles.length,
      tagCount: tags.length,
      userCount: users.length,
      ...summarizeData(articles, tags, users)
    }
  };
}

export async function searchByKeyword(keyword, searchIn, page = 1, limit = 20) {
  // 限制每页最大数量
  const maxLimit = 100;
  const safeLimit = Math.min(limit, maxLimit);
  
  // 分页逻辑
  const startIndex = (page - 1) * safeLimit;
  const endIndex = startIndex + safeLimit;
  
  // 只返回当前页数据
  return results.slice(startIndex, endIndex);
}

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  // 验证必需参数
  if (name === 'search_articles_by_author' && !args.author) {
    return {
      content: [{
        type: 'text',
        text: JSON.stringify({
          success: false,
          error: 'Parameter "author" is required',
        }),
      }],
      isError: true,
    };
  }
  
  // 验证参数类型和范围
  if (args.page && (typeof args.page !== 'number' || args.page < 1)) {
    return {
      content: [{
        type: 'text',
        text: JSON.stringify({
          success: false,
          error: 'Parameter "page" must be a positive number',
        }),
      }],
      isError: true,
    };
  }
  
  // 执行工具逻辑
  // ...
});