@rahmantech/knl-view 0.1.0 → 0.3.0

package/server/graph/sources.js

@@ -3,6 +3,7 @@ import path from 'node:path'
 import { GraphNode } from './model.js'
 import { edgeKey } from './anchordb_client.js'
 import { SYNTAX_LANGUAGES, extractCode } from './syntax.js'
+import { createPathMatcher } from '../config.js'
 
 // Sources graph: the whole project as a dependency graph in AnchorDB, not
 // just the .knowledges markdown. Nodes are the files (id = repo relative
@@ -47,7 +48,7 @@ const REVERSE_EDGE = {
 const DEFAULT_LABEL_DIR = '.knowledges/.knl-data'
 const DEFAULT_IGNORES = ['node_modules', 'dist', 'build', 'coverage']
 
-const JS_EXTS = new Set(['.js', '.mjs', '.cjs'])
+const JS_TS_EXTS = new Set(['.js', '.mjs', '.cjs', '.jsx', '.ts', '.mts', '.cts', '.tsx'])
 
 /** One ignore rule after parsing a .gitignore line. */
 function ignoreRule(line) {
@@ -72,27 +73,42 @@ function fileAttrs(stat) {
  * graph: { rel -> { size, mtime } }. Skips dot-prefixed folders except
  * .github, the default ignore list, and basic .gitignore patterns.
  */
-export async function scanSourceFiles(rootAbs) {
+function compileIgnorePattern(pattern) {
+  if (!pattern || !pattern.includes('*')) return null
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '[^/]*')
+  try {
+    return new RegExp('^' + escaped + '$')
+  } catch {
+    return null
+  }
+}
+
+export async function scanSourceFiles(rootAbs, { include = null, exclude = null } = {}) {
+  const excludeFilter = createPathMatcher(exclude)
+  const includeFilter = createPathMatcher(include)
+
   const rules = []
   try {
     const gitignore = await fs.readFile(path.join(rootAbs, '.gitignore'), 'utf8')
     for (const line of gitignore.split('\n')) {
       const rule = ignoreRule(line)
-      if (rule) rules.push(rule)
+      if (rule) {
+        rule.regex = compileIgnorePattern(rule.pattern)
+        rules.push(rule)
+      }
     }
   } catch {
     // No .gitignore: the default list still applies.
   }
-  rules.push(...DEFAULT_IGNORES.map((pattern) => ({ dirOnly: true, pattern })))
+  rules.push(...DEFAULT_IGNORES.map((pattern) => ({ dirOnly: true, pattern, regex: compileIgnorePattern(pattern) })))
 
-  const ignored = (rel) => {
+  const isDefaultIgnored = (rel, isDir) => {
     const segments = rel.split('/')
     if (segments.some((s) => s.startsWith('.') && s !== '.github')) return true
     return segments.some((segment) =>
       rules.some((rule) => {
-        if (rule.pattern.includes('*')) {
-          const re = new RegExp('^' + rule.pattern.replace(/\*/g, '[^/]*') + '$')
-          return re.test(segment) || re.test(rel)
+        if (rule.regex) {
+          return rule.regex.test(segment) || rule.regex.test(rel)
         }
         if (rule.dirOnly) return segments.includes(rule.pattern)
         return segment === rule.pattern || rel === rule.pattern
@@ -109,15 +125,39 @@ export async function scanSourceFiles(rootAbs) {
       return
     }
     for (const entry of entries) {
-      if (entry.name.startsWith('.') && entry.name !== '.github') continue
       const childRel = rel ? `${rel}/${entry.name}` : entry.name
-      if (ignored(childRel)) continue
-      const childAbs = path.join(dirAbs, entry.name)
+
+      // 1. Hard exclude: knl-config exclude is truly excluded, always wins
+      if (excludeFilter && excludeFilter.matches(childRel, entry.name)) {
+        continue
+      }
+
+      // 2. Explicit include overrides default excludes
+      const isExplicitlyIncluded = includeFilter && includeFilter.matches(childRel, entry.name)
+      const isDirPrefixOfInclude = entry.isDirectory() && includeFilter && includeFilter.isPrefixOfAny(childRel)
+
       if (entry.isDirectory()) {
-        await walk(childAbs, childRel)
+        if (!isExplicitlyIncluded && !isDirPrefixOfInclude) {
+          if (includeFilter) {
+            continue
+          }
+          if (isDefaultIgnored(childRel, true)) {
+            continue
+          }
+        }
+        await walk(path.join(dirAbs, entry.name), childRel)
         continue
       }
+
       if (!entry.isFile()) continue
+
+      if (includeFilter) {
+        if (!isExplicitlyIncluded) continue
+      } else {
+        if (isDefaultIgnored(childRel, false)) continue
+      }
+
+      const childAbs = path.join(dirAbs, entry.name)
       try {
         files[childRel] = fileAttrs(await fs.stat(childAbs))
       } catch {
@@ -175,17 +215,108 @@ export function resolveGoSpecifiers(spec, modulePath, files) {
 
 /**
  * Resolve one relative specifier from file `fromRel` against the set of
- * scanned files. Tries the exact path, the JS extensions, and an index
- * file inside the directory.
+ * scanned files. Tries the exact path, JS/TS extension fallbacks (including
+ * mapping .js specifiers in TS ESM to .ts/.tsx on disk), and directory index files.
  */
 export function resolveImportSpecifier(fromRel, spec, files) {
   const base = path.posix.normalize(path.posix.join(path.posix.dirname(fromRel), spec))
   const candidates = [base]
-  for (const ext of JS_EXTS) candidates.push(base + ext)
-  for (const ext of JS_EXTS) candidates.push(`${base}/index${ext}`)
+  if (base.endsWith('.js')) {
+    candidates.push(base.slice(0, -3) + '.ts', base.slice(0, -3) + '.tsx')
+  } else if (base.endsWith('.mjs')) {
+    candidates.push(base.slice(0, -4) + '.mts')
+  } else if (base.endsWith('.cjs')) {
+    candidates.push(base.slice(0, -4) + '.cts')
+  }
+  for (const ext of JS_TS_EXTS) candidates.push(base + ext)
+  for (const ext of JS_TS_EXTS) candidates.push(`${base}/index${ext}`)
   return candidates.find((candidate) => files[candidate]) || null
 }
 
+/**
+ * Resolve Python import specifiers: relative dots (e.g. .local, ..utils) and
+ * module paths (e.g. pkg.sub) to .py or /__init__.py files in scanned files.
+ */
+export function resolvePySpecifiers(fromRel, specs, files) {
+  const dir = path.posix.dirname(fromRel)
+  const resolved = []
+  for (const spec of specs) {
+    const candidates = []
+    const m = spec.match(/^(\.+)(.*)$/)
+    if (m) {
+      const dotCount = m[1].length
+      const rest = m[2].replace(/\./g, '/')
+      let targetDir = dir
+      for (let i = 1; i < dotCount; i++) targetDir = path.posix.dirname(targetDir)
+      const base = rest ? path.posix.normalize(path.posix.join(targetDir, rest)) : targetDir
+      candidates.push(base + '.py', path.posix.join(base, '__init__.py'))
+    } else {
+      const asPath = spec.replace(/\./g, '/')
+      candidates.push(
+        asPath + '.py',
+        path.posix.join(asPath, '__init__.py'),
+        path.posix.normalize(path.posix.join(dir, asPath)) + '.py',
+        path.posix.normalize(path.posix.join(dir, asPath, '__init__.py'))
+      )
+    }
+    const found = candidates.find((c) => files[c])
+    if (found && !resolved.includes(found)) resolved.push(found)
+  }
+  return resolved
+}
+
+/**
+ * Resolve Rust import specifiers: `crate::`, `super::`, `self::`, and `./`
+ * (from `mod foo;`) to .rs or /mod.rs files in scanned files.
+ */
+export function resolveRustSpecifiers(fromRel, specs, files) {
+  const dir = path.posix.dirname(fromRel)
+  let crateRoot = '.'
+  const srcIdx = fromRel.indexOf('src/')
+  if (srcIdx >= 0) {
+    crateRoot = fromRel.slice(0, srcIdx + 3)
+  }
+  const resolved = []
+  for (const spec of specs) {
+    const candidates = []
+    if (spec.startsWith('crate::')) {
+      const rest = spec.slice('crate::'.length).split('::').join('/')
+      const parts = rest.split('/')
+      for (let i = parts.length; i >= 1; i--) {
+        const sub = parts.slice(0, i).join('/')
+        candidates.push(
+          path.posix.normalize(path.posix.join(crateRoot, sub)) + '.rs',
+          path.posix.normalize(path.posix.join(crateRoot, sub, 'mod.rs'))
+        )
+      }
+    } else if (spec.startsWith('super::')) {
+      const rest = spec.slice('super::'.length).split('::').join('/')
+      const parentDir = path.posix.dirname(dir)
+      const parts = rest.split('/')
+      for (let i = parts.length; i >= 1; i--) {
+        const sub = parts.slice(0, i).join('/')
+        candidates.push(
+          path.posix.normalize(path.posix.join(parentDir, sub)) + '.rs',
+          path.posix.normalize(path.posix.join(parentDir, sub, 'mod.rs'))
+        )
+      }
+    } else if (spec.startsWith('self::') || spec.startsWith('./')) {
+      const raw = spec.startsWith('self::') ? spec.slice('self::'.length).split('::').join('/') : spec.slice(2)
+      const parts = raw.split('/')
+      for (let i = parts.length; i >= 1; i--) {
+        const sub = parts.slice(0, i).join('/')
+        candidates.push(
+          path.posix.normalize(path.posix.join(dir, sub)) + '.rs',
+          path.posix.normalize(path.posix.join(dir, sub, 'mod.rs'))
+        )
+      }
+    }
+    const found = candidates.find((c) => files[c])
+    if (found && !resolved.includes(found)) resolved.push(found)
+  }
+  return resolved
+}
+
 /**
  * Build the desired sources graph: nodes for every scanned file plus one
  * node per named symbol, and edges from tree-sitter extraction (file-level
@@ -193,8 +324,8 @@ export function resolveImportSpecifier(fromRel, spec, files) {
  * `<path>#<name>`; class methods are `Class.method`. Returns plain arrays
  * so callers can diff without depending on the DirectedGraph type.
  */
-export async function buildSourcesGraph(rootAbs, files = null) {
-  const scanned = files || await scanSourceFiles(rootAbs)
+export async function buildSourcesGraph(rootAbs, files = null, options = {}) {
+  const scanned = files || await scanSourceFiles(rootAbs, options)
   const modulePath = await goModulePath(rootAbs)
   const edges = []
   const symbolIndex = new Map() // symbol name -> [node id, ...] for call resolution
@@ -241,9 +372,16 @@ export async function buildSourcesGraph(rootAbs, files = null) {
   }
 
   for (const [rel, file] of Object.entries(structure)) {
-    const targets = file.ext === '.go'
-      ? file.imports.flatMap((spec) => resolveGoSpecifiers(spec, file.modulePath, scanned))
-      : resolveJsSpecifiers(rel, file.imports, scanned)
+    let targets = []
+    if (file.ext === '.go') {
+      targets = file.imports.flatMap((spec) => resolveGoSpecifiers(spec, file.modulePath, scanned))
+    } else if (file.ext === '.py') {
+      targets = resolvePySpecifiers(rel, file.imports, scanned)
+    } else if (file.ext === '.rs') {
+      targets = resolveRustSpecifiers(rel, file.imports, scanned)
+    } else {
+      targets = resolveJsSpecifiers(rel, file.imports, scanned)
+    }
     for (const target of targets) {
       if (target && target !== rel) edges.push({ from: rel, to: target, type: 'imports' })
     }
@@ -359,7 +497,10 @@ export function labelContent(rel, symbols) {
  * symbol is gone. Generated files only; never touches anything else.
  */
 export async function writeLabelFiles(rootAbs, labelDir = DEFAULT_LABEL_DIR, symbolsByFile) {
-  const base = path.join(rootAbs, labelDir)
+  const base = path.resolve(rootAbs, labelDir)
+  if (base !== rootAbs && !base.startsWith(rootAbs + path.sep)) {
+    throw new Error(`labelDir "${labelDir}" resolves outside the project root`)
+  }
   const expected = new Map()
   for (const [rel, symbols] of symbolsByFile) expected.set(rel, labelContent(rel, symbols))
 
@@ -423,8 +564,8 @@ export async function writeLabelFiles(rootAbs, labelDir = DEFAULT_LABEL_DIR, sym
  * @returns {Promise<{linked, unlinked, saved, tombstoned, failed, orphans,
  *   files, symbols, edges, labels}>}
  */
-export async function syncSourcesToAnchorDB(client, rootAbs, { labelDir } = {}) {
-  const { nodes, edges, symbolsByFile } = await buildSourcesGraph(rootAbs)
+export async function syncSourcesToAnchorDB(client, rootAbs, { labelDir, include = null, exclude = null } = {}) {
+  const { nodes, edges, symbolsByFile } = await buildSourcesGraph(rootAbs, null, { include, exclude })
   const desired = desiredSourceEdgeKeys(edges)
   const diskIds = new Set(nodes.map((node) => node.id))
 

package/server/graph/syntax.js

@@ -15,15 +15,26 @@ const require = createRequire(import.meta.url)
 
 const GRAMMAR_WASM = {
   javascript: 'tree-sitter-javascript/tree-sitter-javascript.wasm',
-  go: 'tree-sitter-go/tree-sitter-go.wasm'
+  typescript: 'tree-sitter-typescript/tree-sitter-typescript.wasm',
+  tsx: 'tree-sitter-typescript/tree-sitter-tsx.wasm',
+  go: 'tree-sitter-go/tree-sitter-go.wasm',
+  python: 'tree-sitter-python/tree-sitter-python.wasm',
+  rust: 'tree-sitter-rust/tree-sitter-rust.wasm'
 }
 
-/** The JS family shares one grammar; each other extension has its own. */
+/** The JS/TS, Go, Python, and Rust families; each extension maps to its grammar. */
 export const SYNTAX_LANGUAGES = {
   '.js': 'javascript',
   '.mjs': 'javascript',
   '.cjs': 'javascript',
-  '.go': 'go'
+  '.jsx': 'javascript',
+  '.ts': 'typescript',
+  '.mts': 'typescript',
+  '.cts': 'typescript',
+  '.tsx': 'tsx',
+  '.go': 'go',
+  '.py': 'python',
+  '.rs': 'rust'
 }
 
 let initPromise = null
@@ -67,12 +78,14 @@ function firstDescendant(node, type) {
 function specsFromTree(grammar, tree) {
   const specs = []
   const names = []
+  const bindings = []
   const visit = (node) => {
-    if (grammar === 'javascript') {
+    if (grammar === 'javascript' || grammar === 'typescript' || grammar === 'tsx') {
       if (node.type === 'import_statement' || node.type === 'export_statement') {
         const source = node.childForFieldName('source')
         const fragment = source && firstDescendant(source, 'string_fragment')
-        if (fragment) specs.push(fragment.text)
+        const specText = fragment ? fragment.text : null
+        if (specText) specs.push(specText)
         // Local binding names a qualified call may be addressed through:
         // the default import, the namespace alias, and each named import.
         for (let i = 0; i < node.childCount; i++) {
@@ -80,17 +93,25 @@ function specsFromTree(grammar, tree) {
           if (clause.type !== 'import_clause') continue
           for (let j = 0; j < clause.childCount; j++) {
             const part = clause.child(j)
-            if (part.type === 'identifier') names.push(part.text)
-            else if (part.type === 'namespace_import') {
+            if (part.type === 'identifier') {
+              names.push(part.text)
+              if (specText) bindings.push({ name: part.text, spec: specText })
+            } else if (part.type === 'namespace_import') {
               for (let k = 0; k < part.childCount; k++) {
-                if (part.child(k).type === 'identifier') names.push(part.child(k).text)
+                if (part.child(k).type === 'identifier') {
+                  names.push(part.child(k).text)
+                  if (specText) bindings.push({ name: part.child(k).text, spec: specText })
+                }
               }
             } else if (part.type === 'named_imports') {
               for (let k = 0; k < part.childCount; k++) {
                 const specifier = part.child(k)
                 if (specifier.type !== 'import_specifier') continue
                 const alias = specifier.childForFieldName('alias') || specifier.childForFieldName('name')
-                if (alias) names.push(alias.text)
+                if (alias) {
+                  names.push(alias.text)
+                  if (specText) bindings.push({ name: alias.text, spec: specText })
+                }
               }
             }
           }
@@ -100,7 +121,8 @@ function specsFromTree(grammar, tree) {
         if (fn && (fn.text === 'require' || fn.text === 'import')) {
           const args = node.childForFieldName('arguments')
           const fragment = args && firstDescendant(args, 'string_fragment')
-          if (fragment) specs.push(fragment.text)
+          const specText = fragment ? fragment.text : null
+          if (specText) specs.push(specText)
           // `const x = require('y')` / `const x = await import('y')`: the
           // declarator name is the binding: the visit starts above it, so
           // walk down from any enclosing declarator via field lookup here.
@@ -108,7 +130,10 @@ function specsFromTree(grammar, tree) {
           while (parent && parent.type === 'await_expression') parent = parent.parent
           if (parent && parent.type === 'variable_declarator') {
             const name = parent.childForFieldName('name')
-            if (name) names.push(name.text)
+            if (name) {
+              names.push(name.text)
+              if (specText) bindings.push({ name: name.text, spec: specText })
+            }
           }
         }
       }
@@ -122,15 +147,119 @@ function specsFromTree(grammar, tree) {
           // The name a qualified call uses: the declared alias, or the last
           // path segment (Go's convention when no alias is given).
           const alias = node.childForFieldName('name')
-          if (alias) names.push(alias.text)
-          else names.push(path.slice(path.lastIndexOf('/') + 1))
+          const name = alias ? alias.text : path.slice(path.lastIndexOf('/') + 1)
+          names.push(name)
+          bindings.push({ name, spec: path })
+        }
+      }
+    } else if (grammar === 'python') {
+      if (node.type === 'import_statement') {
+        for (let i = 0; i < node.childCount; i++) {
+          const c = node.child(i)
+          if (c.type === 'dotted_name') {
+            specs.push(c.text)
+            const firstId = c.child(0)
+            if (firstId) {
+              names.push(firstId.text)
+              bindings.push({ name: firstId.text, spec: c.text })
+            }
+          } else if (c.type === 'aliased_import') {
+            const name = c.childForFieldName('name')
+            const alias = c.childForFieldName('alias')
+            if (name) specs.push(name.text)
+            if (alias) {
+              names.push(alias.text)
+              bindings.push({ name: alias.text, spec: name ? name.text : alias.text })
+            }
+          }
+        }
+      } else if (node.type === 'import_from_statement') {
+        const mod = node.childForFieldName('module_name')
+        const modText = mod ? mod.text : ''
+        if (modText) specs.push(modText)
+        let pastImport = false
+        for (let i = 0; i < node.childCount; i++) {
+          const c = node.child(i)
+          if (c.type === 'import') {
+            pastImport = true
+            continue
+          }
+          if (!pastImport) continue
+          if (c.type === 'dotted_name') {
+            names.push(c.text)
+            if (modText) specs.push(modText + '.' + c.text)
+            bindings.push({ name: c.text, spec: modText || c.text })
+          } else if (c.type === 'aliased_import') {
+            const name = c.childForFieldName('name')
+            const alias = c.childForFieldName('alias')
+            if (alias) {
+              names.push(alias.text)
+              bindings.push({ name: alias.text, spec: modText || (name ? name.text : alias.text) })
+            }
+            if (name && modText) specs.push(modText + '.' + name.text)
+          }
+        }
+      }
+    } else if (grammar === 'rust') {
+      if (node.type === 'mod_item') {
+        if (!node.childForFieldName('body')) {
+          const name = node.childForFieldName('name')
+          if (name) {
+            specs.push('./' + name.text)
+            names.push(name.text)
+            bindings.push({ name: name.text, spec: './' + name.text })
+          }
+        }
+      } else if (node.type === 'use_declaration') {
+        const extractRustUse = (n, prefix = '') => {
+          if (!n) return
+          if (n.type === 'scoped_use_list') {
+            const pathNode = n.childForFieldName('path')
+            const listNode = n.childForFieldName('list')
+            const p = (prefix ? prefix + '::' : '') + (pathNode ? pathNode.text : '')
+            extractRustUse(listNode, p)
+          } else if (n.type === 'use_list') {
+            for (let i = 0; i < n.childCount; i++) {
+              const c = n.child(i)
+              if (c.type === 'identifier' || c.type === 'scoped_identifier' || c.type === 'use_as_clause' || c.type === 'scoped_use_list') {
+                extractRustUse(c, prefix)
+              }
+            }
+          } else if (n.type === 'use_as_clause') {
+            const pathNode = n.childForFieldName('path')
+            const aliasNode = n.childForFieldName('alias')
+            const full = (prefix ? prefix + '::' : '') + (pathNode ? pathNode.text : '')
+            specs.push(full)
+            const alias = aliasNode ? aliasNode.text : null
+            if (alias) {
+              names.push(alias)
+              const crateName = full.split('::')[0]
+              bindings.push({ name: alias, spec: crateName, full })
+            }
+          } else if (n.type === 'scoped_identifier') {
+            const full = (prefix ? prefix + '::' : '') + n.text
+            specs.push(full)
+            const name = n.childForFieldName('name')
+            if (name) {
+              names.push(name.text)
+              const crateName = full.split('::')[0]
+              bindings.push({ name: name.text, spec: crateName, full })
+            }
+          } else if (n.type === 'identifier') {
+            const full = (prefix ? prefix + '::' : '') + n.text
+            specs.push(full)
+            names.push(n.text)
+            const crateName = full.split('::')[0]
+            bindings.push({ name: n.text, spec: crateName, full })
+          }
         }
+        extractRustUse(node.childForFieldName('argument'))
       }
     }
     for (let i = 0; i < node.childCount; i++) visit(node.child(i))
   }
   visit(tree.rootNode)
-  return { specs, names }
+  return { specs, names, bindings }
 }
 
 /**
@@ -170,9 +299,9 @@ export async function extractCode(ext, content) {
   const parser = parserFor(grammar, lang)
   const tree = parser.parse(content)
   try {
-    const { specs: imports, names: importNames } = specsFromTree(grammar, tree)
+    const { specs: imports, names: importNames, bindings: importBindings } = specsFromTree(grammar, tree)
     const { symbols, calls } = structureFromTree(grammar, tree)
-    return { imports, importNames, symbols, calls }
+    return { imports, importNames, importBindings, symbols, calls }
   } finally {
     tree.delete()
   }
@@ -195,7 +324,7 @@ function structureFromTree(grammar, tree) {
     })
   }
   const visit = (node, cls) => {
-    if (grammar === 'javascript') {
+    if (grammar === 'javascript' || grammar === 'typescript' || grammar === 'tsx') {
       if (node.type === 'function_declaration' || node.type === 'generator_function_declaration') {
         const name = node.childForFieldName('name')
         if (name) pushSymbol(node, name.text, 'function')
@@ -220,6 +349,15 @@ function structureFromTree(grammar, tree) {
             pushSymbol(declarator, name.text, 'function')
           }
         }
+      } else if (node.type === 'interface_declaration') {
+        const name = node.childForFieldName('name')
+        if (name) pushSymbol(node, name.text, 'interface')
+      } else if (node.type === 'type_alias_declaration') {
+        const name = node.childForFieldName('name')
+        if (name) pushSymbol(node, name.text, 'type')
+      } else if (node.type === 'enum_declaration') {
+        const name = node.childForFieldName('name')
+        if (name) pushSymbol(node, name.text, 'enum')
       }
     } else if (grammar === 'go') {
       if (node.type === 'function_declaration') {
@@ -234,18 +372,97 @@ function structureFromTree(grammar, tree) {
         const name = node.childForFieldName('name')
         if (name) pushSymbol(node, name.text, 'type')
       }
+    } else if (grammar === 'python') {
+      if (node.type === 'class_definition') {
+        const name = node.childForFieldName('name')
+        if (name) {
+          pushSymbol(node, name.text, 'class')
+          cls = name.text
+        }
+      } else if (node.type === 'function_definition') {
+        const name = node.childForFieldName('name')
+        if (name) {
+          if (cls) pushSymbol(node, `${cls}.${name.text}`, 'method')
+          else pushSymbol(node, name.text, 'function')
+        }
+      }
+    } else if (grammar === 'rust') {
+      if (node.type === 'struct_item') {
+        const name = node.childForFieldName('name')
+        if (name) pushSymbol(node, name.text, 'struct')
+      } else if (node.type === 'enum_item') {
+        const name = node.childForFieldName('name')
+        if (name) pushSymbol(node, name.text, 'enum')
+      } else if (node.type === 'trait_item') {
+        const name = node.childForFieldName('name')
+        if (name) pushSymbol(node, name.text, 'trait')
+      } else if (node.type === 'type_item') {
+        const name = node.childForFieldName('name')
+        if (name) pushSymbol(node, name.text, 'type')
+      } else if (node.type === 'impl_item') {
+        const typeNode = node.childForFieldName('type')
+        if (typeNode) cls = typeNode.text
+      } else if (node.type === 'function_item') {
+        const name = node.childForFieldName('name')
+        if (name) {
+          if (cls) pushSymbol(node, `${cls}.${name.text}`, 'method')
+          else pushSymbol(node, name.text, 'function')
+        }
+      }
     }
-    if (node.type === 'call_expression' || node.type === 'new_expression') {
-      const fn = node.type === 'call_expression'
-        ? node.childForFieldName('function')
-        : node.childForFieldName('constructor')
-      if (fn) {
-        if (fn.type === 'identifier') {
-          calls.push({ name: fn.text, recv: null, row: node.startPosition.row })
-        } else if (fn.type === 'member_expression' || fn.type === 'selector_expression') {
-          const named = fn.namedChildren
-          if (named.length >= 2) {
-            calls.push({ name: named[named.length - 1].text, recv: named[0].text, row: node.startPosition.row })
+
+    if (grammar === 'python') {
+      if (node.type === 'call') {
+        const fn = node.childForFieldName('function')
+        if (fn) {
+          if (fn.type === 'identifier') {
+            calls.push({ name: fn.text, recv: null, row: node.startPosition.row })
+          } else if (fn.type === 'attribute') {
+            const obj = fn.childForFieldName('object')
+            const attr = fn.childForFieldName('attribute')
+            if (attr) {
+              calls.push({ name: attr.text, recv: obj ? obj.text : null, row: node.startPosition.row })
+            }
+          }
+        }
+      }
+    } else if (grammar === 'rust') {
+      if (node.type === 'call_expression') {
+        const fn = node.childForFieldName('function')
+        if (fn) {
+          if (fn.type === 'identifier') {
+            calls.push({ name: fn.text, recv: null, row: node.startPosition.row })
+          } else if (fn.type === 'field_expression') {
+            const val = fn.childForFieldName('value')
+            const field = fn.childForFieldName('field')
+            if (field) {
+              calls.push({ name: field.text, recv: val ? val.text : null, row: node.startPosition.row })
+            }
+          } else if (fn.type === 'scoped_identifier') {
+            const pathNode = fn.childForFieldName('path')
+            const nameNode = fn.childForFieldName('name')
+            if (nameNode) {
+              const recv = pathNode
+                ? (pathNode.type === 'scoped_identifier' ? (pathNode.childForFieldName('name') || pathNode).text : pathNode.text)
+                : null
+              calls.push({ name: nameNode.text, recv, row: node.startPosition.row })
+            }
+          }
+        }
+      }
+    } else {
+      if (node.type === 'call_expression' || node.type === 'new_expression') {
+        const fn = node.type === 'call_expression'
+          ? node.childForFieldName('function')
+          : node.childForFieldName('constructor')
+        if (fn) {
+          if (fn.type === 'identifier') {
+            calls.push({ name: fn.text, recv: null, row: node.startPosition.row })
+          } else if (fn.type === 'member_expression' || fn.type === 'selector_expression') {
+            const named = fn.namedChildren
+            if (named.length >= 2) {
+              calls.push({ name: named[named.length - 1].text, recv: named[0].text, row: node.startPosition.row })
+            }
           }
         }
       }