leveraging tree-sitter to build a dependency graph

[itsPreto]

I've managed to spin up a working version of this, however...

I've got a lot of hard-coded logic for the specific languages I was working with (java & kotlin)-- which is less than idea.

Question: are there any known approaches that allow me to generate a simple json out of the AST? like so:

{
  "file": "path/to/source/file.extension",
  "contents": {
    "content_type": "class",  // or "object", "interface", etc.
    "functions": [
      {
        "name": "functionName1",
        "returnType": "String",  // Optional, based on language
        "parameters": [
          {"name": "param1", "type": "int"},
          {"name": "param2", "type": "String"}
        ]
      },
      // ... other functions
    ],
    "variables": [
      {
        "name": "variableName1",
        "type": "int"
      },
      // ... other variables
    ],
    "imports": [
      "import/path/1",
      "import/path/2",
      // ... other imports
    ]
  }
}

this is what the madness I'm currently doing looks like (please tell me there's an easier way):

[maxbrunsfeld]

I converted this from an issue into a discussion.

As for your actual question, my gut reaction is that you probably need a special *query& per language, but you may be able to have your actual code be language-agnostic, if you structure your query in a general enough way.

[itsPreto]

Thanks for the reply! Could you elaborate on what you mean by

special *query& per language

is that just referring, for instance, to the query_string I show in the screenshot? or more in general the traversal algorithm?

My goal is a drag-and-drop like feature where I can import a local project-- detecting the languages present are easy enough but I can't think of a nice way to handle all the setup and parsing [agnostically].

So far I compiled a list of all the different grammar repos like this one so that at runtime I can clone/build the missing ones as needed. Once I have the language.so for the matched languages the actual parsing is as simple as:

parser = Parser()
parser.set_language(LANGUAGE)
tree = parser.parse(code)

Am I just doomed? Should just accept the fact that I'll need handwritten traversal/query logic for each detected language :(

[maxbrunsfeld]

I think it’s probably possible to have the code be generic across languages, and just write your queries so they produce matches with a common set of captures. Good luck.