cloudflare-mcp-smart-proxy 1.0.2 → 1.1.1

package/package-personal.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-mcp-smart-proxy",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "description": "Smart proxy for Cloudflare MCP - routes tools to cloud or local execution",
   "type": "module",
   "main": "index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-mcp-smart-proxy",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "description": "Smart proxy for Cloudflare MCP - routes tools to cloud or local execution",
   "type": "module",
   "main": "index.js",

package/src/local-tools.js

@@ -5,6 +5,9 @@
 import { FileOperations } from './tools/file-operations.js';
 import { EditFile } from './tools/edit-file.js';
 import { CommandExecutor } from './tools/command-executor.js';
+import { FileSearch } from './tools/file-search.js';
+import { SymbolTools } from './tools/symbol-tools.js';
+import { Diagnostics } from './tools/diagnostics.js';
 
 export class LocalToolExecutor {
   constructor(workspaceRoot) {
@@ -38,6 +41,21 @@ export class LocalToolExecutor {
       case 'execute_shell_command':
         return await CommandExecutor.execute(params, this.workspaceRoot);
       
+      case 'search_files':
+        return await FileSearch.searchFiles(params, this.workspaceRoot);
+      
+      case 'search_symbols':
+        return await SymbolTools.searchSymbols(params, this.workspaceRoot);
+      
+      case 'get_symbol_definition':
+        return await SymbolTools.getSymbolDefinition(params, this.workspaceRoot);
+      
+      case 'get_document_symbols':
+        return await SymbolTools.getDocumentSymbols(params, this.workspaceRoot);
+      
+      case 'get_diagnostics':
+        return await Diagnostics.getDiagnostics(params, this.workspaceRoot);
+      
       default:
         throw new Error(`Unknown local tool: ${toolName}`);
     }
@@ -190,6 +208,112 @@ export class LocalToolExecutor {
           },
           required: ['command']
         }
+      },
+      {
+        name: 'search_files',
+        description: 'Search for files by name or content in local filesystem',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: {
+              type: 'string',
+              description: 'Search query (matches filename or file content)'
+            },
+            directory: {
+              type: 'string',
+              description: 'Directory to search in (default: current directory)'
+            },
+            maxResults: {
+              type: 'number',
+              description: 'Maximum number of results (default: 50)'
+            },
+            filePattern: {
+              type: 'string',
+              description: 'File pattern to match (e.g., "*.js", "*.ts")'
+            },
+            caseSensitive: {
+              type: 'boolean',
+              description: 'Whether search is case sensitive (default: false)'
+            }
+          },
+          required: ['query']
+        }
+      },
+      {
+        name: 'search_symbols',
+        description: 'Search for code symbols (functions, classes, variables) in local filesystem',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: {
+              type: 'string',
+              description: 'Symbol name to search for'
+            },
+            directory: {
+              type: 'string',
+              description: 'Directory to search in (default: current directory)'
+            },
+            maxResults: {
+              type: 'number',
+              description: 'Maximum number of results (default: 50)'
+            },
+            filePattern: {
+              type: 'string',
+              description: 'File pattern to match (e.g., "*.js", "*.ts")'
+            }
+          },
+          required: ['query']
+        }
+      },
+      {
+        name: 'get_symbol_definition',
+        description: 'Get the definition of a symbol in a file',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_path: {
+              type: 'string',
+              description: 'Path to the file containing the symbol'
+            },
+            symbol: {
+              type: 'string',
+              description: 'Name of the symbol to find'
+            },
+            line: {
+              type: 'number',
+              description: 'Line number where the symbol is used (optional, helps narrow search)'
+            }
+          },
+          required: ['file_path', 'symbol']
+        }
+      },
+      {
+        name: 'get_document_symbols',
+        description: 'Get all symbols (outline) in a document',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_path: {
+              type: 'string',
+              description: 'Path to the file to analyze'
+            }
+          },
+          required: ['file_path']
+        }
+      },
+      {
+        name: 'get_diagnostics',
+        description: 'Get code diagnostics (errors, warnings) for a file',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_path: {
+              type: 'string',
+              description: 'Path to the file to analyze'
+            }
+          },
+          required: ['file_path']
+        }
       }
     ];
   }

package/src/router.js

@@ -129,7 +129,24 @@ export class SmartRouter {
       const result = await response.json();
       
       if (result.error) {
-        throw new Error(result.error.message || 'Cloud tool execution failed');
+        // MCP 标准格式：详细错误信息在 data 字段中
+        // 如果 data 是对象，尝试提取更多信息
+        let errorMessage = result.error.data || result.error.message || 'Cloud tool execution failed';
+        
+        // 如果 data 是对象，尝试提取 message 或格式化整个对象
+        if (typeof errorMessage === 'object') {
+          errorMessage = errorMessage.message || JSON.stringify(errorMessage, null, 2);
+        }
+        
+        // 记录详细错误信息用于调试
+        console.error(`[SmartRouter] Cloud tool error for ${toolName}:`, {
+          code: result.error.code,
+          message: result.error.message,
+          data: result.error.data,
+          fullError: result.error
+        });
+        
+        throw new Error(errorMessage);
       }
       
       // 提取结果内容
@@ -137,7 +154,16 @@ export class SmartRouter {
         // MCP 标准格式
         const content = result.result.content;
         if (Array.isArray(content) && content.length > 0) {
-          return content[0].text;
+          const text = content[0].text;
+          // 尝试解析 JSON 字符串，如果失败则返回原始字符串
+          try {
+            const parsed = JSON.parse(text);
+            // 如果解析成功且是对象，返回对象；否则返回原始字符串
+            return typeof parsed === 'object' && parsed !== null ? parsed : text;
+          } catch {
+            // 不是 JSON，直接返回字符串
+            return text;
+          }
         }
         return content;
       } else if (result.result) {
@@ -146,6 +172,18 @@ export class SmartRouter {
         return result;
       }
     } catch (error) {
+      // 记录完整错误信息用于调试
+      console.error(`[SmartRouter] Error calling cloud tool ${toolName}:`, {
+        error: error.message,
+        stack: error.stack,
+        params: params
+      });
+      
+      // 如果错误信息已经包含 "Cloud tool call failed"，直接抛出
+      // 否则添加前缀
+      if (error.message && error.message.includes('Cloud tool call failed')) {
+        throw error;
+      }
       throw new Error(`Cloud tool call failed: ${error.message}`);
     }
   }

package/src/tools/diagnostics.js

@@ -0,0 +1,128 @@
+/**
+ * Diagnostics - 代码诊断工具
+ * 提供基础的代码检查功能
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { FileOperations } from './file-operations.js';
+
+export class Diagnostics {
+  /**
+   * 获取文件诊断信息
+   */
+  static async getDiagnostics(params, workspaceRoot) {
+    const { file_path } = params;
+    
+    if (!file_path) {
+      throw new Error('file_path parameter is required');
+    }
+    
+    const filePath = FileOperations.validatePath(file_path, workspaceRoot);
+    const diagnostics = [];
+    
+    try {
+      const stats = await fs.stat(filePath);
+      
+      // 只处理代码文件
+      const codeExtensions = ['.js', '.ts', '.jsx', '.tsx', '.py', '.java', '.cpp', '.c'];
+      const ext = path.extname(file_path).toLowerCase();
+      
+      if (!codeExtensions.includes(ext)) {
+        return {
+          file: file_path,
+          diagnostics: [],
+          total: 0
+        };
+      }
+      
+      const content = await fs.readFile(filePath, 'utf-8');
+      const lines = content.split('\n');
+      
+      // 基础语法检查（简单规则）
+      lines.forEach((line, index) => {
+        const lineNum = index + 1;
+        const trimmed = line.trim();
+        
+        // 检查未闭合的括号
+        const openParens = (line.match(/\(/g) || []).length;
+        const closeParens = (line.match(/\)/g) || []).length;
+        const openBraces = (line.match(/\{/g) || []).length;
+        const closeBraces = (line.match(/\}/g) || []).length;
+        const openBrackets = (line.match(/\[/g) || []).length;
+        const closeBrackets = (line.match(/\]/g) || []).length;
+        
+        // 检查未闭合的字符串
+        const singleQuotes = (line.match(/'/g) || []).length;
+        const doubleQuotes = (line.match(/"/g) || []).length;
+        const backticks = (line.match(/`/g) || []).length;
+        
+        // 简单的警告（不是真正的语法检查，只是模式匹配）
+        if (trimmed && !trimmed.startsWith('//') && !trimmed.startsWith('*') && !trimmed.startsWith('/*')) {
+          // 检查常见的潜在问题
+          if (trimmed.includes('console.log') && !trimmed.includes('//')) {
+            diagnostics.push({
+              line: lineNum,
+              column: line.indexOf('console.log') + 1,
+              severity: 'warning',
+              message: 'console.log found - consider removing in production',
+              source: 'basic-linter'
+            });
+          }
+          
+          // 检查未使用的变量模式（简单检查）
+          if (trimmed.match(/^(const|let|var)\s+\w+\s*=\s*[^;]+;\s*$/)) {
+            // 这是一个简单的变量声明，但无法真正判断是否使用
+            // 这里只是示例，实际需要 AST 解析
+          }
+          
+          // 检查可能的语法错误模式
+          if (trimmed.endsWith(',') && !trimmed.includes('//')) {
+            // 可能是尾随逗号（在某些情况下是合法的）
+          }
+        }
+      });
+      
+      // 检查文件编码问题
+      try {
+        // 尝试检测 BOM
+        if (content.charCodeAt(0) === 0xFEFF) {
+          diagnostics.push({
+            line: 1,
+            column: 1,
+            severity: 'warning',
+            message: 'File contains BOM (Byte Order Mark)',
+            source: 'encoding-check'
+          });
+        }
+      } catch (e) {
+        // 忽略
+      }
+      
+      // 检查行尾一致性
+      const hasCRLF = content.includes('\r\n');
+      const hasLF = content.includes('\n') && !hasCRLF;
+      if (hasCRLF && hasLF) {
+        diagnostics.push({
+          line: 1,
+          column: 1,
+          severity: 'info',
+          message: 'File contains mixed line endings',
+          source: 'line-ending-check'
+        });
+      }
+      
+      return {
+        file: file_path,
+        diagnostics: diagnostics.slice(0, 100), // 限制诊断数量
+        total: diagnostics.length
+      };
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`File not found: ${file_path}`);
+      }
+      throw new Error(`Failed to get diagnostics: ${error.message}`);
+    }
+  }
+}
+

package/src/tools/file-search.js

@@ -0,0 +1,133 @@
+/**
+ * File Search - 文件搜索工具
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { FileOperations } from './file-operations.js';
+
+export class FileSearch {
+  /**
+   * 搜索文件
+   */
+  static async searchFiles(params, workspaceRoot) {
+    const { 
+      query, 
+      directory = '.',
+      maxResults = 50,
+      filePattern = null,
+      caseSensitive = false
+    } = params;
+    
+    if (!query) {
+      throw new Error('query parameter is required');
+    }
+    
+    const searchDir = FileOperations.validatePath(directory, workspaceRoot);
+    const results = [];
+    const searchRegex = new RegExp(
+      caseSensitive ? query : query.toLowerCase(),
+      caseSensitive ? 'g' : 'gi'
+    );
+    
+    // 文件模式匹配
+    let filePatternRegex = null;
+    if (filePattern) {
+      // 简单的 glob 转正则（支持 * 和 ?）
+      const pattern = filePattern
+        .replace(/\./g, '\\.')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+      filePatternRegex = new RegExp(pattern, caseSensitive ? '' : 'i');
+    }
+    
+    /**
+     * 递归搜索文件
+     */
+    async function searchDirectory(currentDir) {
+      try {
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+          const fullPath = path.join(currentDir, entry.name);
+          const relativePath = path.relative(workspaceRoot, fullPath);
+          
+          // 跳过 node_modules, .git 等常见目录
+          if (entry.name.startsWith('.') && entry.name !== '.') {
+            continue;
+          }
+          if (entry.name === 'node_modules' || entry.name === '.git') {
+            continue;
+          }
+          
+          if (entry.isDirectory()) {
+            await searchDirectory(fullPath);
+          } else if (entry.isFile()) {
+            // 检查文件模式
+            if (filePatternRegex && !filePatternRegex.test(entry.name)) {
+              continue;
+            }
+            
+            // 搜索文件名
+            const fileNameMatch = searchRegex.test(entry.name);
+            
+            // 搜索文件内容（仅文本文件）
+            let contentMatches = [];
+            if (fileNameMatch || !filePattern) {
+              try {
+                const stats = await fs.stat(fullPath);
+                // 只搜索小于 1MB 的文件
+                if (stats.size < 1024 * 1024) {
+                  const content = await fs.readFile(fullPath, 'utf-8');
+                  const lines = content.split('\n');
+                  
+                  lines.forEach((line, index) => {
+                    if (searchRegex.test(line)) {
+                      contentMatches.push({
+                        line: index + 1,
+                        content: line.trim().substring(0, 200) // 限制长度
+                      });
+                    }
+                  });
+                  
+                  // 重置正则（因为 test 会改变 lastIndex）
+                  searchRegex.lastIndex = 0;
+                }
+              } catch (error) {
+                // 忽略无法读取的文件（二进制文件等）
+              }
+            }
+            
+            // 如果文件名或内容匹配，添加到结果
+            if (fileNameMatch || contentMatches.length > 0) {
+              results.push({
+                file: relativePath,
+                fileName: entry.name,
+                fileNameMatch,
+                contentMatches: contentMatches.slice(0, 10), // 限制每个文件的匹配数
+                matchCount: contentMatches.length
+              });
+              
+              if (results.length >= maxResults) {
+                return; // 达到最大结果数，停止搜索
+              }
+            }
+          }
+        }
+      } catch (error) {
+        // 忽略权限错误，继续搜索其他目录
+        console.error(`Error searching ${currentDir}:`, error.message);
+      }
+    }
+    
+    await searchDirectory(searchDir);
+    
+    return {
+      query,
+      directory,
+      results: results.slice(0, maxResults),
+      total: results.length
+    };
+  }
+}
+

package/src/tools/symbol-tools.js

@@ -0,0 +1,329 @@
+/**
+ * Symbol Tools - 符号搜索和定义工具
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { FileOperations } from './file-operations.js';
+
+export class SymbolTools {
+  /**
+   * 搜索符号（函数、类、变量等）
+   */
+  static async searchSymbols(params, workspaceRoot) {
+    const { 
+      query, 
+      directory = '.',
+      maxResults = 50,
+      filePattern = null
+    } = params;
+    
+    if (!query) {
+      throw new Error('query parameter is required');
+    }
+    
+    const searchDir = FileOperations.validatePath(directory, workspaceRoot);
+    const results = [];
+    
+    // 文件模式匹配
+    let filePatternRegex = null;
+    if (filePattern) {
+      const pattern = filePattern
+        .replace(/\./g, '\\.')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+      filePatternRegex = new RegExp(pattern, 'i');
+    }
+    
+    // 符号定义模式（支持多种语言）
+    const symbolPatterns = [
+      // JavaScript/TypeScript
+      /^(export\s+)?(function|class|const|let|var|interface|type|enum)\s+(\w+)/,
+      /^(export\s+)?(async\s+)?function\s+(\w+)/,
+      /^(export\s+)?(const|let|var)\s+(\w+)\s*[:=]/,
+      // Python
+      /^(def|class)\s+(\w+)/,
+      // Java/C++
+      /^(public|private|protected)?\s*(static)?\s*(class|interface|enum|void|int|String|boolean)\s+(\w+)/,
+    ];
+    
+    /**
+     * 递归搜索符号
+     */
+    async function searchDirectory(currentDir) {
+      try {
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+          const fullPath = path.join(currentDir, entry.name);
+          const relativePath = path.relative(workspaceRoot, fullPath);
+          
+          // 跳过常见目录
+          if (entry.name.startsWith('.') && entry.name !== '.') {
+            continue;
+          }
+          if (entry.name === 'node_modules' || entry.name === '.git') {
+            continue;
+          }
+          
+          if (entry.isDirectory()) {
+            await searchDirectory(fullPath);
+          } else if (entry.isFile()) {
+            // 检查文件模式
+            if (filePatternRegex && !filePatternRegex.test(entry.name)) {
+              continue;
+            }
+            
+            // 只搜索代码文件
+            const codeExtensions = ['.js', '.ts', '.jsx', '.tsx', '.py', '.java', '.cpp', '.c', '.h', '.hpp'];
+            const ext = path.extname(entry.name).toLowerCase();
+            if (!codeExtensions.includes(ext)) {
+              continue;
+            }
+            
+            try {
+              const stats = await fs.stat(fullPath);
+              // 只搜索小于 500KB 的文件
+              if (stats.size > 500 * 1024) {
+                continue;
+              }
+              
+              const content = await fs.readFile(fullPath, 'utf-8');
+              const lines = content.split('\n');
+              
+              lines.forEach((line, index) => {
+                for (const pattern of symbolPatterns) {
+                  const match = line.match(pattern);
+                  if (match) {
+                    const symbolName = match[match.length - 1]; // 最后一个捕获组是符号名
+                    
+                    // 检查是否匹配查询（模糊匹配）
+                    if (symbolName.toLowerCase().includes(query.toLowerCase())) {
+                      // 确定符号类型
+                      let kind = 'unknown';
+                      if (line.includes('function') || line.includes('def')) {
+                        kind = 'function';
+                      } else if (line.includes('class')) {
+                        kind = 'class';
+                      } else if (line.includes('interface') || line.includes('type')) {
+                        kind = 'interface';
+                      } else if (line.includes('enum')) {
+                        kind = 'enum';
+                      } else if (line.includes('const') || line.includes('let') || line.includes('var')) {
+                        kind = 'variable';
+                      }
+                      
+                      results.push({
+                        name: symbolName,
+                        kind,
+                        file: relativePath,
+                        line: index + 1,
+                        content: line.trim().substring(0, 150)
+                      });
+                      
+                      if (results.length >= maxResults) {
+                        return;
+                      }
+                    }
+                  }
+                }
+              });
+            } catch (error) {
+              // 忽略无法读取的文件
+            }
+            
+            if (results.length >= maxResults) {
+              return;
+            }
+          }
+        }
+      } catch (error) {
+        console.error(`Error searching ${currentDir}:`, error.message);
+      }
+    }
+    
+    await searchDirectory(searchDir);
+    
+    return {
+      query,
+      symbols: results.slice(0, maxResults),
+      total: results.length
+    };
+  }
+  
+  /**
+   * 获取符号定义
+   */
+  static async getSymbolDefinition(params, workspaceRoot) {
+    const { file_path, symbol, line } = params;
+    
+    if (!file_path || !symbol) {
+      throw new Error('file_path and symbol parameters are required');
+    }
+    
+    const filePath = FileOperations.validatePath(file_path, workspaceRoot);
+    
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const lines = content.split('\n');
+      
+      // 如果提供了行号，从该行开始搜索
+      const startLine = line ? Math.max(0, line - 1) : 0;
+      const searchRange = line ? 20 : lines.length; // 如果提供了行号，只搜索附近20行
+      
+      // 符号定义模式
+      const definitionPatterns = [
+        new RegExp(`(export\\s+)?(function|class|const|let|var|interface|type|enum)\\s+${symbol}\\b`),
+        new RegExp(`(export\\s+)?(async\\s+)?function\\s+${symbol}\\b`),
+        new RegExp(`(export\\s+)?(const|let|var)\\s+${symbol}\\s*[:=]`),
+        new RegExp(`(def|class)\\s+${symbol}\\b`),
+      ];
+      
+      let definitionLine = -1;
+      let definitionContent = '';
+      
+      // 从指定行向上搜索
+      for (let i = startLine; i >= 0 && i >= startLine - searchRange; i--) {
+        for (const pattern of definitionPatterns) {
+          if (pattern.test(lines[i])) {
+            definitionLine = i + 1;
+            definitionContent = lines[i];
+            break;
+          }
+        }
+        if (definitionLine !== -1) break;
+      }
+      
+      // 如果向上没找到，向下搜索
+      if (definitionLine === -1) {
+        for (let i = startLine; i < lines.length && i < startLine + searchRange; i++) {
+          for (const pattern of definitionPatterns) {
+            if (pattern.test(lines[i])) {
+              definitionLine = i + 1;
+              definitionContent = lines[i];
+              break;
+            }
+          }
+          if (definitionLine !== -1) break;
+        }
+      }
+      
+      if (definitionLine === -1) {
+        throw new Error(`Symbol definition not found: ${symbol}`);
+      }
+      
+      // 提取 JSDoc/注释（向上查找）
+      let documentation = '';
+      for (let i = definitionLine - 2; i >= 0 && i >= definitionLine - 10; i--) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/**') || trimmed.startsWith('*/')) {
+          documentation = lines[i] + '\n' + documentation;
+        } else if (trimmed === '' && documentation) {
+          // 空行，继续查找注释
+          continue;
+        } else {
+          break;
+        }
+      }
+      
+      // 确定符号类型
+      let kind = 'unknown';
+      if (definitionContent.includes('function') || definitionContent.includes('def')) {
+        kind = 'function';
+      } else if (definitionContent.includes('class')) {
+        kind = 'class';
+      } else if (definitionContent.includes('interface') || definitionContent.includes('type')) {
+        kind = 'interface';
+      } else if (definitionContent.includes('enum')) {
+        kind = 'enum';
+      } else if (definitionContent.includes('const') || definitionContent.includes('let') || definitionContent.includes('var')) {
+        kind = 'variable';
+      }
+      
+      return {
+        symbol,
+        kind,
+        file: file_path,
+        line: definitionLine,
+        content: definitionContent.trim(),
+        documentation: documentation.trim()
+      };
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`File not found: ${file_path}`);
+      }
+      throw new Error(`Failed to get symbol definition: ${error.message}`);
+    }
+  }
+  
+  /**
+   * 获取文档符号（文件大纲）
+   */
+  static async getDocumentSymbols(params, workspaceRoot) {
+    const { file_path } = params;
+    
+    if (!file_path) {
+      throw new Error('file_path parameter is required');
+    }
+    
+    const filePath = FileOperations.validatePath(file_path, workspaceRoot);
+    
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const lines = content.split('\n');
+      const symbols = [];
+      
+      // 符号定义模式
+      const symbolPatterns = [
+        // 类
+        { pattern: /^(export\s+)?class\s+(\w+)/, kind: 'class' },
+        { pattern: /^class\s+(\w+)/, kind: 'class' },
+        // 函数
+        { pattern: /^(export\s+)?(async\s+)?function\s+(\w+)/, kind: 'function' },
+        { pattern: /^def\s+(\w+)/, kind: 'function' },
+        // 接口/类型
+        { pattern: /^(export\s+)?interface\s+(\w+)/, kind: 'interface' },
+        { pattern: /^(export\s+)?type\s+(\w+)/, kind: 'type' },
+        // 枚举
+        { pattern: /^(export\s+)?enum\s+(\w+)/, kind: 'enum' },
+        // 变量/常量
+        { pattern: /^(export\s+)?const\s+(\w+)/, kind: 'variable' },
+        { pattern: /^(export\s+)?let\s+(\w+)/, kind: 'variable' },
+      ];
+      
+      lines.forEach((line, index) => {
+        for (const { pattern, kind } of symbolPatterns) {
+          const match = line.match(pattern);
+          if (match) {
+            const symbolName = match[match.length - 1]; // 最后一个捕获组
+            const indent = line.match(/^(\s*)/)?.[1]?.length || 0;
+            
+            symbols.push({
+              name: symbolName,
+              kind,
+              line: index + 1,
+              indent,
+              content: line.trim().substring(0, 100)
+            });
+            break; // 只匹配第一个模式
+          }
+        }
+      });
+      
+      // 按行号排序
+      symbols.sort((a, b) => a.line - b.line);
+      
+      return {
+        file: file_path,
+        symbols,
+        total: symbols.length
+      };
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`File not found: ${file_path}`);
+      }
+      throw new Error(`Failed to get document symbols: ${error.message}`);
+    }
+  }
+}
+