autosnippet 3.0.3 → 3.0.7

package/lib/core/ast/lang-rust.js

@@ -0,0 +1,695 @@
+/**
+ * @module lang-rust
+ * @description Rust AST Walker 插件
+ *
+ * 提取: struct, enum, trait, impl, function, method, mod, use, const/static
+ * 模式: Builder, Newtype, Factory (new/from), Error Handling (Result/Option/?),
+ *        Async (tokio/async-std), Unsafe block, Derive macro
+ */
+
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+function walkRust(root, ctx) {
+  for (let i = 0; i < root.namedChildCount; i++) {
+    const child = root.namedChild(i);
+    _walkNode(child, ctx);
+  }
+}
+
+function _walkNode(node, ctx) {
+  switch (node.type) {
+    case 'use_declaration': {
+      _parseUseDecl(node, ctx);
+      break;
+    }
+
+    case 'mod_item': {
+      _parseModItem(node, ctx);
+      break;
+    }
+
+    case 'struct_item': {
+      _parseStruct(node, ctx);
+      break;
+    }
+
+    case 'enum_item': {
+      _parseEnum(node, ctx);
+      break;
+    }
+
+    case 'trait_item': {
+      _parseTrait(node, ctx);
+      break;
+    }
+
+    case 'impl_item': {
+      _parseImpl(node, ctx);
+      break;
+    }
+
+    case 'function_item': {
+      const funcInfo = _parseFunctionItem(node);
+      if (funcInfo) {
+        ctx.methods.push(funcInfo);
+      }
+      break;
+    }
+
+    case 'const_item':
+    case 'static_item': {
+      _parseConstStatic(node, ctx);
+      break;
+    }
+
+    case 'type_item': {
+      _parseTypeAlias(node, ctx);
+      break;
+    }
+
+    case 'macro_definition': {
+      _parseMacroDef(node, ctx);
+      break;
+    }
+
+    // 带 attribute 的顶层项
+    case 'attribute_item':
+    case 'inner_attribute_item':
+      break;
+
+    default:
+      break;
+  }
+}
+
+// ── Use Declaration ──────────────────────────────────────────
+
+function _parseUseDecl(node, ctx) {
+  // 提取 use 路径文本
+  const argNode = node.namedChildren.find(
+    (c) => c.type === 'use_wildcard' ||
+           c.type === 'use_list' ||
+           c.type === 'use_as_clause' ||
+           c.type === 'scoped_identifier' ||
+           c.type === 'identifier' ||
+           c.type === 'scoped_use_list'
+  );
+  if (argNode) {
+    ctx.imports.push(argNode.text);
+  }
+}
+
+// ── Mod Item ─────────────────────────────────────────────────
+
+function _parseModItem(node, ctx) {
+  const nameNode = node.namedChildren.find((c) => c.type === 'identifier');
+  if (nameNode) {
+    ctx.metadata = ctx.metadata || {};
+    ctx.metadata.modules = ctx.metadata.modules || [];
+    ctx.metadata.modules.push(nameNode.text);
+  }
+  // 如果是 inline mod { ... }，递归内部声明
+  const body = node.namedChildren.find((c) => c.type === 'declaration_list');
+  if (body) {
+    for (let i = 0; i < body.namedChildCount; i++) {
+      _walkNode(body.namedChild(i), ctx);
+    }
+  }
+}
+
+// ── Struct ───────────────────────────────────────────────────
+
+function _parseStruct(node, ctx) {
+  const nameNode = node.namedChildren.find((c) => c.type === 'type_identifier');
+  const name = nameNode?.text || 'Unknown';
+
+  const fields = [];
+  const derives = _extractDerives(node);
+
+  // Named fields (struct Foo { field: Type })
+  const fieldList = node.namedChildren.find((c) => c.type === 'field_declaration_list');
+  if (fieldList) {
+    for (let i = 0; i < fieldList.namedChildCount; i++) {
+      const field = fieldList.namedChild(i);
+      if (field.type !== 'field_declaration') continue;
+      const fieldId = field.namedChildren.find((c) => c.type === 'field_identifier');
+      if (fieldId) {
+        const isPublic = _hasPubVisibility(field);
+        ctx.properties.push({
+          name: fieldId.text,
+          className: name,
+          isExported: isPublic,
+          line: field.startPosition.row + 1,
+        });
+        fields.push(fieldId.text);
+      }
+    }
+  }
+
+  // Tuple struct fields (struct Foo(Type1, Type2))
+  const orderedFields = node.namedChildren.find((c) => c.type === 'ordered_field_declaration_list');
+  if (orderedFields) {
+    let idx = 0;
+    for (let i = 0; i < orderedFields.namedChildCount; i++) {
+      const child = orderedFields.namedChild(i);
+      // Skip visibility markers
+      if (child.type === 'visibility_modifier') continue;
+      if (child.type.includes('type') || child.type === 'primitive_type' ||
+          child.type === 'scoped_type_identifier' || child.type === 'type_identifier' ||
+          child.type === 'generic_type' || child.type === 'reference_type') {
+        fields.push(`${idx}`);
+        idx++;
+      }
+    }
+  }
+
+  ctx.classes.push({
+    name,
+    kind: 'struct',
+    superclass: null,
+    protocols: [],
+    derives,
+    fieldCount: fields.length,
+    line: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+  });
+}
+
+// ── Enum ─────────────────────────────────────────────────────
+
+function _parseEnum(node, ctx) {
+  const nameNode = node.namedChildren.find((c) => c.type === 'type_identifier');
+  const name = nameNode?.text || 'Unknown';
+  const derives = _extractDerives(node);
+
+  const variants = [];
+  const body = node.namedChildren.find((c) => c.type === 'enum_variant_list');
+  if (body) {
+    for (let i = 0; i < body.namedChildCount; i++) {
+      const variant = body.namedChild(i);
+      if (variant.type === 'enum_variant') {
+        const variantName = variant.namedChildren.find((c) => c.type === 'identifier');
+        if (variantName) {
+          variants.push(variantName.text);
+        }
+      }
+    }
+  }
+
+  ctx.classes.push({
+    name,
+    kind: 'enum',
+    superclass: null,
+    protocols: [],
+    derives,
+    variants,
+    variantCount: variants.length,
+    line: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+  });
+}
+
+// ── Trait ─────────────────────────────────────────────────────
+
+function _parseTrait(node, ctx) {
+  const nameNode = node.namedChildren.find((c) => c.type === 'type_identifier');
+  const name = nameNode?.text || 'Unknown';
+
+  const methods = [];
+  const superTraits = [];
+
+  // Trait bounds (trait Foo: Bar + Baz)
+  const bounds = node.namedChildren.find((c) => c.type === 'trait_bounds');
+  if (bounds) {
+    for (let i = 0; i < bounds.namedChildCount; i++) {
+      const bound = bounds.namedChild(i);
+      if (bound.type === 'type_identifier' || bound.type === 'scoped_type_identifier' ||
+          bound.type === 'generic_type') {
+        superTraits.push(bound.text);
+      }
+    }
+  }
+
+  // Trait body — collect method signatures
+  const body = node.namedChildren.find((c) => c.type === 'declaration_list');
+  if (body) {
+    for (let i = 0; i < body.namedChildCount; i++) {
+      const item = body.namedChild(i);
+      if (item.type === 'function_signature_item' || item.type === 'function_item') {
+        const methodName = item.namedChildren.find((c) => c.type === 'identifier');
+        if (methodName) {
+          methods.push(methodName.text);
+        }
+      }
+    }
+  }
+
+  ctx.protocols.push({
+    name,
+    inherits: superTraits,
+    methods,
+    line: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+  });
+}
+
+// ── Impl Block ───────────────────────────────────────────────
+
+function _parseImpl(node, ctx) {
+  // impl Type { ... } 或 impl Trait for Type { ... }
+  let selfType = null;
+  let traitName = null;
+
+  const typeIdNodes = node.namedChildren.filter(
+    (c) => c.type === 'type_identifier' || c.type === 'scoped_type_identifier' ||
+           c.type === 'generic_type'
+  );
+
+  // 检查是否有 "for" — trait impl
+  const hasFor = node.children?.some((c) => c.type === 'for');
+
+  if (hasFor && typeIdNodes.length >= 2) {
+    traitName = typeIdNodes[0]?.text;
+    selfType = typeIdNodes[1]?.text;
+  } else if (typeIdNodes.length >= 1) {
+    selfType = typeIdNodes[0]?.text;
+  }
+
+  const body = node.namedChildren.find((c) => c.type === 'declaration_list');
+  if (!body || !selfType) return;
+
+  for (let i = 0; i < body.namedChildCount; i++) {
+    const item = body.namedChild(i);
+    if (item.type === 'function_item') {
+      const methodInfo = _parseImplMethod(item, selfType, traitName);
+      if (methodInfo) {
+        ctx.methods.push(methodInfo);
+      }
+    }
+  }
+}
+
+function _parseImplMethod(node, selfType, traitName) {
+  const nameNode = node.namedChildren.find((c) => c.type === 'identifier');
+  const name = nameNode?.text;
+  if (!name) return null;
+
+  const params = node.namedChildren.find((c) => c.type === 'parameters');
+  const { paramCount, hasSelfParam } = params ? _countRustParams(params) : { paramCount: 0, hasSelfParam: false };
+
+  const isPublic = _hasPubVisibility(node);
+  const isAsync = node.children?.some((c) => c.text === 'async') || false;
+
+  const body = node.namedChildren.find((c) => c.type === 'block');
+  const bodyLines = body ? body.endPosition.row - body.startPosition.row + 1 : 0;
+  const complexity = body ? _estimateComplexity(body) : 1;
+  const nestingDepth = body ? _maxNesting(body, 0) : 0;
+
+  return {
+    name,
+    className: selfType,
+    isClassMethod: !hasSelfParam, // 无 self → associated function (static)
+    isExported: isPublic,
+    isAsync,
+    traitImpl: traitName || null,
+    paramCount,
+    bodyLines,
+    complexity,
+    nestingDepth,
+    line: node.startPosition.row + 1,
+    kind: 'definition',
+  };
+}
+
+// ── Function Item (free fn) ──────────────────────────────────
+
+function _parseFunctionItem(node) {
+  const nameNode = node.namedChildren.find((c) => c.type === 'identifier');
+  const name = nameNode?.text;
+  if (!name) return null;
+
+  const params = node.namedChildren.find((c) => c.type === 'parameters');
+  const { paramCount } = params ? _countRustParams(params) : { paramCount: 0 };
+
+  const isPublic = _hasPubVisibility(node);
+  const isAsync = node.children?.some((c) => c.text === 'async') || false;
+  const isUnsafe = node.children?.some((c) => c.text === 'unsafe') || false;
+
+  const body = node.namedChildren.find((c) => c.type === 'block');
+  const bodyLines = body ? body.endPosition.row - body.startPosition.row + 1 : 0;
+  const complexity = body ? _estimateComplexity(body) : 1;
+  const nestingDepth = body ? _maxNesting(body, 0) : 0;
+
+  return {
+    name,
+    className: null,
+    isClassMethod: true, // free function → "static" equivalent
+    isExported: isPublic,
+    isAsync,
+    isUnsafe,
+    paramCount,
+    bodyLines,
+    complexity,
+    nestingDepth,
+    line: node.startPosition.row + 1,
+    kind: 'definition',
+  };
+}
+
+// ── Const / Static ───────────────────────────────────────────
+
+function _parseConstStatic(node, ctx) {
+  const isConst = node.type === 'const_item';
+  const nameNode = node.namedChildren.find((c) => c.type === 'identifier');
+  if (nameNode) {
+    ctx.properties.push({
+      name: nameNode.text,
+      className: null,
+      isExported: _hasPubVisibility(node),
+      isConst,
+      isStatic: !isConst,
+      line: node.startPosition.row + 1,
+    });
+  }
+}
+
+// ── Type Alias ───────────────────────────────────────────────
+
+function _parseTypeAlias(node, ctx) {
+  const nameNode = node.namedChildren.find((c) => c.type === 'type_identifier');
+  if (nameNode) {
+    ctx.classes.push({
+      name: nameNode.text,
+      kind: 'type-alias',
+      line: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1,
+    });
+  }
+}
+
+// ── Macro Definition ─────────────────────────────────────────
+
+function _parseMacroDef(node, ctx) {
+  const nameNode = node.namedChildren.find((c) => c.type === 'identifier');
+  if (nameNode) {
+    ctx.metadata = ctx.metadata || {};
+    ctx.metadata.macros = ctx.metadata.macros || [];
+    ctx.metadata.macros.push({
+      name: nameNode.text,
+      line: node.startPosition.row + 1,
+    });
+  }
+}
+
+// ── Rust Pattern Detection ───────────────────────────────────
+
+function detectRustPatterns(root, lang, methods, properties, classes) {
+  const patterns = [];
+
+  // 构建 type → methods 索引
+  const typeMethodMap = {};
+  for (const m of methods) {
+    if (m.className) {
+      if (!typeMethodMap[m.className]) {
+        typeMethodMap[m.className] = [];
+      }
+      typeMethodMap[m.className].push(m);
+    }
+  }
+
+  // Builder pattern: struct 有 builder() 或一系列链式 with_*/set_* 方法
+  for (const [typeName, methodList] of Object.entries(typeMethodMap)) {
+    const hasBuilder = methodList.some((m) => m.name === 'builder' || m.name === 'build');
+    const chainMethods = methodList.filter((m) =>
+      /^(?:with_|set_|add_)/.test(m.name)
+    );
+    if (hasBuilder || chainMethods.length >= 3) {
+      patterns.push({
+        type: 'builder',
+        className: typeName,
+        confidence: hasBuilder ? 0.9 : 0.7,
+      });
+    }
+  }
+
+  // Factory: new() / from() / create() associated functions
+  for (const m of methods) {
+    if (
+      m.className &&
+      m.isClassMethod && // associated function (no self)
+      /^(?:new|from|create|open|connect|with_capacity|default)$/.test(m.name)
+    ) {
+      patterns.push({
+        type: 'factory',
+        className: m.className,
+        methodName: m.name,
+        line: m.line,
+        confidence: 0.85,
+      });
+    }
+  }
+
+  // Newtype pattern: struct with single field
+  for (const cls of classes) {
+    if (cls.kind === 'struct' && cls.fieldCount === 1) {
+      patterns.push({
+        type: 'newtype',
+        className: cls.name,
+        line: cls.line,
+        confidence: 0.75,
+      });
+    }
+  }
+
+  // Error enum pattern: enum with Error/Err suffix or derives thiserror
+  for (const cls of classes) {
+    if (cls.kind === 'enum' && /(?:Error|Err)$/.test(cls.name)) {
+      patterns.push({
+        type: 'error-enum',
+        className: cls.name,
+        variantCount: cls.variantCount || 0,
+        line: cls.line,
+        confidence: 0.9,
+      });
+    }
+  }
+
+  // Trait impl richness: types with many methods suggest impl-heavy design
+  for (const [typeName, methodList] of Object.entries(typeMethodMap)) {
+    if (methodList.length >= 3) {
+      const traitImpls = new Set(methodList.filter((m) => m.traitImpl).map((m) => m.traitImpl));
+      patterns.push({
+        type: 'impl-rich',
+        className: typeName,
+        methodCount: methodList.length,
+        traitImplCount: traitImpls.size,
+        confidence: 0.7,
+      });
+    }
+  }
+
+  // Unsafe usage
+  _detectUnsafe(root, patterns);
+
+  // Async usage
+  _detectAsync(root, patterns);
+
+  // Derive macro analysis
+  _detectDerives(classes, patterns);
+
+  return patterns;
+}
+
+function _detectUnsafe(root, patterns) {
+  let count = 0;
+  function walk(node) {
+    if (node.type === 'unsafe_block') {
+      count++;
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      walk(node.namedChild(i));
+    }
+  }
+  walk(root);
+  if (count > 0) {
+    patterns.push({
+      type: 'unsafe',
+      count,
+      confidence: 0.95,
+    });
+  }
+}
+
+function _detectAsync(root, patterns) {
+  let asyncFnCount = 0;
+  let awaitCount = 0;
+  function walk(node) {
+    if (node.type === 'function_item' || node.type === 'function_signature_item') {
+      const isAsync = node.children?.some((c) => c.text === 'async');
+      if (isAsync) asyncFnCount++;
+    }
+    if (node.type === 'await_expression') {
+      awaitCount++;
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      walk(node.namedChild(i));
+    }
+  }
+  walk(root);
+  if (asyncFnCount > 0 || awaitCount > 0) {
+    patterns.push({
+      type: 'async',
+      asyncFunctions: asyncFnCount,
+      awaitExpressions: awaitCount,
+      confidence: 0.9,
+    });
+  }
+}
+
+function _detectDerives(classes, patterns) {
+  const deriveCounts = {};
+  for (const cls of classes) {
+    if (cls.derives) {
+      for (const d of cls.derives) {
+        deriveCounts[d] = (deriveCounts[d] || 0) + 1;
+      }
+    }
+  }
+  const commonDerives = Object.entries(deriveCounts)
+    .filter(([, count]) => count >= 2)
+    .map(([name, count]) => ({ name, count }));
+
+  if (commonDerives.length > 0) {
+    patterns.push({
+      type: 'derive-usage',
+      derives: commonDerives,
+      confidence: 0.8,
+    });
+  }
+}
+
+// ── Helper: Extract #[derive(...)] ──────────────────────────
+
+function _extractDerives(node) {
+  const derives = [];
+  // Look at preceding siblings (attribute_item nodes)
+  if (node.parent) {
+    const siblings = [];
+    for (let i = 0; i < node.parent.namedChildCount; i++) {
+      const sib = node.parent.namedChild(i);
+      if (sib === node) break;
+      siblings.push(sib);
+    }
+    // Collect attribute_item nodes immediately before this node
+    for (let i = siblings.length - 1; i >= 0; i--) {
+      const sib = siblings[i];
+      if (sib.type !== 'attribute_item') break;
+      const text = sib.text;
+      const deriveMatch = text.match(/#\[derive\(([^)]+)\)\]/);
+      if (deriveMatch) {
+        const items = deriveMatch[1].split(',').map((s) => s.trim());
+        derives.push(...items);
+      }
+    }
+  }
+  return derives;
+}
+
+// ── Helper: Visibility ──────────────────────────────────────
+
+function _hasPubVisibility(node) {
+  return node.children?.some(
+    (c) => c.type === 'visibility_modifier' || c.text === 'pub'
+  ) || false;
+}
+
+// ── Helper: Count Parameters ────────────────────────────────
+
+function _countRustParams(paramList) {
+  let paramCount = 0;
+  let hasSelfParam = false;
+
+  for (let i = 0; i < paramList.namedChildCount; i++) {
+    const child = paramList.namedChild(i);
+    if (child.type === 'self_parameter') {
+      hasSelfParam = true;
+      // Don't count self in paramCount
+    } else if (child.type === 'parameter') {
+      paramCount++;
+    }
+  }
+  return { paramCount, hasSelfParam };
+}
+
+// ── Utility: Complexity ─────────────────────────────────────
+
+function _estimateComplexity(node) {
+  let complexity = 1;
+  const BRANCH_TYPES = new Set([
+    'if_expression',
+    'if_let_expression',
+    'for_expression',
+    'while_expression',
+    'while_let_expression',
+    'loop_expression',
+    'match_expression',
+    'match_arm',
+  ]);
+  function walk(n) {
+    if (BRANCH_TYPES.has(n.type)) {
+      complexity++;
+    }
+    if (n.type === 'binary_expression') {
+      const op = n.children?.find((c) => c.text === '&&' || c.text === '||');
+      if (op) {
+        complexity++;
+      }
+    }
+    for (let i = 0; i < n.namedChildCount; i++) {
+      walk(n.namedChild(i));
+    }
+  }
+  walk(node);
+  return complexity;
+}
+
+function _maxNesting(node, depth) {
+  const NESTING_TYPES = new Set([
+    'if_expression',
+    'if_let_expression',
+    'for_expression',
+    'while_expression',
+    'while_let_expression',
+    'loop_expression',
+    'match_expression',
+    'block',
+  ]);
+  let max = depth;
+  const nextDepth = NESTING_TYPES.has(node.type) ? depth + 1 : depth;
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const childMax = _maxNesting(node.namedChild(i), nextDepth);
+    if (childMax > max) {
+      max = childMax;
+    }
+  }
+  return max;
+}
+
+// ── Plugin Export ────────────────────────────────────────────
+
+let _grammar = null;
+function getGrammar() {
+  if (!_grammar) {
+    _grammar = require('tree-sitter-rust');
+  }
+  return _grammar;
+}
+
+export const plugin = {
+  getGrammar,
+  walk: walkRust,
+  detectPatterns: detectRustPatterns,
+  extensions: ['.rs'],
+};

package/lib/core/discovery/PythonDiscoverer.js

@@ -214,6 +214,9 @@ export class PythonDiscoverer extends ProjectDiscoverer {
     if (deps.has('fastapi')) {
       return 'fastapi';
     }
+    if (deps.has('langchain') || deps.has('langchain-core') || deps.has('langgraph') || deps.has('llama-index') || deps.has('llama_index')) {
+      return 'langchain';
+    }
     if (deps.has('torch') || deps.has('tensorflow')) {
       return 'ml';
     }