mr-sliy 1.0.0

package/src/services/ast/parser.js

@@ -0,0 +1,503 @@
+/**
+ * Tree-sitter AST解析服务
+ * 支持多语言源代码解析为AST语法树
+ * 优先使用npm包中的语言解析器，降级策略：无解析器时使用基础正则解析
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { logger } = require('../../utils/logger');
+const { getFileLanguage } = require('../../utils/helpers');
+
+const languageParsers = new Map();
+let Parser = null;
+let parserInitialized = false;
+
+const WASM_DIR = path.join(__dirname, '..', '..', '..', 'wasm');
+
+const languageMap = {
+  javascript: 'javascript',
+  typescript: 'typescript',
+  python: 'python',
+  java: 'java',
+  go: 'go',
+  rust: 'rust',
+  c: 'c',
+  cpp: 'cpp',
+  csharp: 'c_sharp',
+  ruby: 'ruby',
+  php: 'php',
+  swift: 'swift',
+  kotlin: 'kotlin',
+  scala: 'scala'
+};
+
+const npmPackageMap = {
+  javascript: 'tree-sitter-javascript',
+  typescript: 'tree-sitter-typescript',
+  python: 'tree-sitter-python',
+  java: 'tree-sitter-java',
+  go: 'tree-sitter-go',
+  rust: 'tree-sitter-rust',
+  c: 'tree-sitter-c',
+  cpp: 'tree-sitter-cpp',
+  csharp: 'tree-sitter-c-sharp',
+  ruby: 'tree-sitter-ruby',
+  php: 'tree-sitter-php'
+};
+
+async function initParser() {
+  if (parserInitialized) return;
+  try {
+    Parser = require('web-tree-sitter');
+    await Parser.init();
+    parserInitialized = true;
+    logger.info('Tree-sitter Parser初始化成功');
+  } catch (error) {
+    logger.warn('Tree-sitter Parser初始化失败，将使用基础解析模式:', error.message);
+    Parser = null;
+    parserInitialized = true;
+  }
+}
+
+async function loadLanguage(languageName) {
+  if (languageParsers.has(languageName)) {
+    return languageParsers.get(languageName);
+  }
+
+  if (!Parser) {
+    return null;
+  }
+
+  try {
+    const npmPackage = npmPackageMap[languageName];
+    if (npmPackage) {
+      try {
+        const languageModule = require(npmPackage);
+        const language = Parser.Language.load(languageModule.wasm || path.join(require.resolve(npmPackage), '../', 'tree-sitter-' + languageMap[languageName] + '.wasm'));
+        const parser = new Parser();
+        parser.setLanguage(language);
+        languageParsers.set(languageName, { parser, language });
+        logger.info(`加载语言解析器成功(npm): ${languageName}`);
+        return { parser, language };
+      } catch (npmError) {
+        logger.debug(`npm包加载失败，尝试WASM文件: ${npmError.message}`);
+      }
+    }
+
+    const wasmFileName = languageMap[languageName] || languageName;
+    const wasmPath = path.join(WASM_DIR, `tree-sitter-${wasmFileName}.wasm`);
+
+    if (!fs.existsSync(wasmPath)) {
+      logger.warn(`语言WASM文件不存在: ${wasmPath}`);
+      return null;
+    }
+
+    const language = await Parser.Language.load(wasmPath);
+    const parser = new Parser();
+    parser.setLanguage(language);
+
+    languageParsers.set(languageName, { parser, language });
+    logger.info(`加载语言解析器成功(wasm): ${languageName}`);
+
+    return { parser, language };
+  } catch (error) {
+    logger.error(`加载语言解析器失败: ${languageName}`, error);
+    return null;
+  }
+}
+
+/**
+ * 基础解析器（降级模式）
+ * 当Tree-sitter不可用时使用正则进行简单解析
+ */
+class FallbackParser {
+  parse(sourceCode) {
+    const lines = sourceCode.split('\n');
+    const nodes = [];
+
+    lines.forEach((line, index) => {
+      // 检测变量声明
+      const varMatch = line.match(/(?:const|let|var)\s+(\w+)/);
+      if (varMatch) {
+        nodes.push({
+          type: 'variable_declarator',
+          text: line.trim(),
+          startPosition: { row: index, column: line.search(/\b(?:const|let|var)\b/) },
+          endPosition: { row: index, column: line.length }
+        });
+      }
+
+      // 检测函数声明
+      const funcMatch = line.match(/function\s+(\w+)/);
+      if (funcMatch) {
+        nodes.push({
+          type: 'function_declaration',
+          text: line.trim(),
+          startPosition: { row: index, column: line.search(/\bfunction\b/) },
+          endPosition: { row: index, column: line.length }
+        });
+      }
+
+      // 检测导入语句
+      const importMatch = line.match(/import\s+/);
+      if (importMatch) {
+        nodes.push({
+          type: 'import_statement',
+          text: line.trim(),
+          startPosition: { row: index, column: 0 },
+          endPosition: { row: index, column: line.length }
+        });
+      }
+
+      // 检测if语句
+      const ifMatch = line.match(/if\s*\(/);
+      if (ifMatch) {
+        nodes.push({
+          type: 'if_statement',
+          text: line.trim(),
+          startPosition: { row: index, column: line.search(/\bif\b/) },
+          endPosition: { row: index, column: line.length }
+        });
+      }
+
+      // 检测for循环
+      const forMatch = line.match(/for\s*\(/);
+      if (forMatch) {
+        nodes.push({
+          type: 'for_statement',
+          text: line.trim(),
+          startPosition: { row: index, column: line.search(/\bfor\b/) },
+          endPosition: { row: index, column: line.length }
+        });
+      }
+
+      // 检测while循环
+      const whileMatch = line.match(/while\s*\(/);
+      if (whileMatch) {
+        nodes.push({
+          type: 'while_statement',
+          text: line.trim(),
+          startPosition: { row: index, column: line.search(/\bwhile\b/) },
+          endPosition: { row: index, column: line.length }
+        });
+      }
+
+      // 检测console.log调用
+      const consoleMatch = line.match(/console\.log\(/);
+      if (consoleMatch) {
+        nodes.push({
+          type: 'call_expression',
+          text: line.trim(),
+          startPosition: { row: index, column: line.search('console.log') },
+          endPosition: { row: index, column: line.length }
+        });
+      }
+
+      // 检测其他函数调用
+      const callMatch = line.match(/(\w+)\s*\(/);
+      if (callMatch && !line.includes('function') && !line.includes('return')) {
+        nodes.push({
+          type: 'call_expression',
+          text: line.trim(),
+          startPosition: { row: index, column: callMatch.index },
+          endPosition: { row: index, column: line.length }
+        });
+      }
+
+      // 检测标识符
+      const idMatches = line.matchAll(/\b([a-zA-Z_]\w*)\b/g);
+      for (const match of idMatches) {
+        const keyword = ['const', 'let', 'var', 'function', 'return', 'if', 'else', 'for', 'while', 'import', 'from', 'class', 'console'];
+        if (!keyword.includes(match[1])) {
+          nodes.push({
+            type: 'identifier',
+            text: match[1],
+            startPosition: { row: index, column: match.index },
+            endPosition: { row: index, column: match.index + match[1].length }
+          });
+        }
+      }
+
+      // 检测数字
+      const numMatches = line.matchAll(/\b(\d+(?:\.\d+)?)\b/g);
+      for (const match of numMatches) {
+        nodes.push({
+          type: 'number',
+          text: match[1],
+          startPosition: { row: index, column: match.index },
+          endPosition: { row: index, column: match.index + match[1].length }
+        });
+      }
+    });
+
+    return {
+      rootNode: {
+        type: 'program',
+        text: sourceCode,
+        startPosition: { row: 0, column: 0 },
+        endPosition: { row: lines.length - 1, column: lines[lines.length - 1]?.length || 0 },
+        childCount: nodes.length,
+        children: nodes
+      }
+    };
+  }
+}
+
+/**
+ * 解析源代码为AST
+ */
+async function parseCode(sourceCode, languageName) {
+  try {
+    await initParser();
+    const langParser = await loadLanguage(languageName);
+
+    if (langParser) {
+      const tree = langParser.parser.parse(sourceCode);
+      return {
+        success: true,
+        tree,
+        language: languageName,
+        rootNode: tree.rootNode
+      };
+    }
+
+    // 降级到基础解析器
+    logger.warn(`Tree-sitter不可用，使用基础解析器: ${languageName}`);
+    const fallback = new FallbackParser();
+    const tree = fallback.parse(sourceCode);
+    return {
+      success: true,
+      tree,
+      language: languageName,
+      rootNode: tree.rootNode,
+      fallback: true
+    };
+  } catch (error) {
+    logger.error('解析代码失败:', error);
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * 解析文件
+ */
+async function parseFile(filePath) {
+  try {
+    const sourceCode = fs.readFileSync(filePath, 'utf-8');
+    const languageName = getFileLanguage(filePath);
+    
+    return await parseCode(sourceCode, languageName);
+  } catch (error) {
+    logger.error(`解析文件失败: ${filePath}`, error);
+    return {
+      success: false,
+      error: error.message,
+      filePath
+    };
+  }
+}
+
+/**
+ * 查询AST节点
+ */
+async function queryNodes(tree, language, queryPattern) {
+  try {
+    const langParser = languageParsers.get(language);
+    if (!langParser) {
+      throw new Error(`语言解析器未加载: ${language}`);
+    }
+    
+    const query = langParser.language.query(queryPattern);
+    const matches = query.matches(tree.rootNode);
+    
+    return matches.map(match => ({
+      pattern: match.pattern,
+      captures: match.captures.map(capture => ({
+        name: capture.name,
+        node: capture.node,
+        text: capture.node.text,
+        startPosition: capture.node.startPosition,
+        endPosition: capture.node.endPosition,
+        startPosition: {
+          row: capture.node.startPosition.row,
+          column: capture.node.startPosition.column
+        },
+        endPosition: {
+          row: capture.node.endPosition.row,
+          column: capture.node.endPosition.column
+        }
+      }))
+    }));
+  } catch (error) {
+    logger.error('查询AST节点失败:', error);
+    return [];
+  }
+}
+
+/**
+ * 遍历AST树
+ */
+function traverseAST(node, callback, depth = 0) {
+  callback(node, depth);
+
+  const children = node.children || (typeof node.childCount === 'number' ? [] : []);
+  for (let i = 0; i < children.length; i++) {
+    traverseAST(children[i], callback, depth + 1);
+  }
+
+  // Tree-sitter原生节点使用child()方法
+  if (node.childCount && typeof node.child === 'function') {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) traverseAST(child, callback, depth + 1);
+    }
+  }
+}
+
+/**
+ * 获取所有特定类型的节点
+ */
+function getNodesByType(rootNode, nodeType) {
+  const nodes = [];
+  
+  traverseAST(rootNode, (node) => {
+    if (node.type === nodeType) {
+      nodes.push({
+        type: node.type,
+        text: node.text,
+        startPosition: {
+          row: node.startPosition.row,
+          column: node.startPosition.column
+        },
+        endPosition: {
+          row: node.endPosition.row,
+          column: node.endPosition.column
+        },
+        children: node.childCount
+      });
+    }
+  });
+  
+  return nodes;
+}
+
+/**
+ * 提取函数声明节点
+ */
+async function extractFunctions(tree) {
+  return getNodesByType(tree.rootNode, 'function_declaration');
+}
+
+/**
+ * 提取变量声明节点
+ */
+async function extractVariables(tree) {
+  return getNodesByType(tree.rootNode, 'variable_declarator');
+}
+
+/**
+ * 提取导入语句节点
+ */
+async function extractImports(tree) {
+  return getNodesByType(tree.rootNode, 'import_statement');
+}
+
+/**
+ * 提取类声明节点
+ */
+async function extractClasses(tree) {
+  return getNodesByType(tree.rootNode, 'class_declaration');
+}
+
+/**
+ * 提取标识符节点
+ */
+async function extractIdentifiers(tree) {
+  return getNodesByType(tree.rootNode, 'identifier');
+}
+
+/**
+ * 获取AST树结构摘要
+ */
+function getASTSummary(tree) {
+  const summary = {
+    totalNodes: 0,
+    nodeTypes: {},
+    maxDepth: 0
+  };
+  
+  traverseAST(tree.rootNode, (node, depth) => {
+    summary.totalNodes++;
+    
+    if (!summary.nodeTypes[node.type]) {
+      summary.nodeTypes[node.type] = 0;
+    }
+    summary.nodeTypes[node.type]++;
+    
+    if (depth > summary.maxDepth) {
+      summary.maxDepth = depth;
+    }
+  });
+  
+  return summary;
+}
+
+/**
+ * 将AST转换为JSON格式（用于存储和传输）
+ */
+function astToJson(node) {
+  return {
+    type: node.type,
+    text: node.text,
+    startPosition: {
+      row: node.startPosition.row,
+      column: node.startPosition.column
+    },
+    endPosition: {
+      row: node.endPosition.row,
+      column: node.endPosition.column
+    },
+    children: node.children ? node.children.map(child => astToJson(child)) : []
+  };
+}
+
+/**
+ * 释放Parser资源
+ */
+function disposeParser() {
+  languageParsers.forEach((langParser, languageName) => {
+    if (langParser.parser) {
+      langParser.parser.dispose();
+    }
+    if (langParser.language) {
+      langParser.language.dispose();
+    }
+    logger.info(`释放语言解析器: ${languageName}`);
+  });
+  
+  languageParsers.clear();
+}
+
+// 不再在模块加载时自动初始化，改为按需初始化（在parseCode中调用）
+
+module.exports = {
+  initParser,
+  loadLanguage,
+  parseCode,
+  parseFile,
+  queryNodes,
+  traverseAST,
+  getNodesByType,
+  extractFunctions,
+  extractVariables,
+  extractImports,
+  extractClasses,
+  extractIdentifiers,
+  getASTSummary,
+  astToJson,
+  disposeParser
+};