src-mcp 1.0.1

package/assets/languages.json

@@ -0,0 +1,219 @@
+{
+  "treesitter": {
+    "javascript": {
+      "wasm": "tree-sitter-javascript.wasm",
+      "queries": "javascript",
+      "extensions": [".js", ".jsx", ".mjs", ".cjs"]
+    },
+    "typescript": {
+      "wasm": "tree-sitter-typescript.wasm",
+      "queries": "typescript",
+      "extensions": [".ts", ".mts", ".cts"]
+    },
+    "tsx": {
+      "wasm": "tree-sitter-tsx.wasm",
+      "queries": "tsx",
+      "extensions": [".tsx"]
+    },
+    "html": {
+      "wasm": "tree-sitter-html.wasm",
+      "queries": "html",
+      "extensions": [".html", ".htm", ".xhtml"]
+    },
+    "svelte": {
+      "wasm": "tree-sitter-svelte.wasm",
+      "queries": "svelte",
+      "extensions": [".svelte"]
+    },
+    "c": {
+      "wasm": "tree-sitter-c.wasm",
+      "queries": "c",
+      "extensions": [".c", ".h"]
+    },
+    "cpp": {
+      "wasm": "tree-sitter-cpp.wasm",
+      "queries": "cpp",
+      "extensions": [".cpp", ".hpp", ".cc", ".hh", ".cxx", ".hxx", ".c++", ".h++"]
+    },
+    "rust": {
+      "wasm": "tree-sitter-rust.wasm",
+      "queries": "rust",
+      "extensions": [".rs"]
+    },
+    "go": {
+      "wasm": "tree-sitter-go.wasm",
+      "queries": "go",
+      "extensions": [".go"]
+    },
+    "java": {
+      "wasm": "tree-sitter-java.wasm",
+      "queries": "java",
+      "extensions": [".java"]
+    },
+    "kotlin": {
+      "wasm": "tree-sitter-kotlin.wasm",
+      "queries": "kotlin",
+      "extensions": [".kt", ".kts"]
+    },
+    "scala": {
+      "wasm": "tree-sitter-scala.wasm",
+      "queries": "scala",
+      "extensions": [".scala", ".sc"]
+    },
+    "python": {
+      "wasm": "tree-sitter-python.wasm",
+      "queries": "python",
+      "extensions": [".py", ".pyi", ".pyw"]
+    },
+    "ruby": {
+      "wasm": "tree-sitter-ruby.wasm",
+      "queries": "ruby",
+      "extensions": [".rb", ".rake", ".gemspec"]
+    },
+    "php": {
+      "wasm": "tree-sitter-php.wasm",
+      "queries": "php",
+      "extensions": [".php", ".phtml", ".php3", ".php4", ".php5", ".phps"]
+    },
+    "ocaml": {
+      "wasm": "tree-sitter-ocaml.wasm",
+      "queries": "ocaml",
+      "extensions": [".ml", ".mli"]
+    },
+    "swift": {
+      "wasm": "tree-sitter-swift.wasm",
+      "queries": "swift",
+      "extensions": [".swift"]
+    },
+    "c_sharp": {
+      "wasm": "tree-sitter-c_sharp.wasm",
+      "queries": "c_sharp",
+      "extensions": [".cs", ".csx"],
+      "aliases": ["csharp"]
+    }
+  },
+  "langchain": {
+    "mapping": {
+      "javascript": "js",
+      "typescript": "js",
+      "tsx": "js",
+      "jsx": "js",
+      "python": "python",
+      "go": "go",
+      "rust": "rust",
+      "java": "java",
+      "cpp": "cpp",
+      "c": "cpp",
+      "html": "html",
+      "markdown": "markdown",
+      "md": "markdown",
+      "ruby": "ruby",
+      "php": "php",
+      "scala": "scala",
+      "swift": "swift",
+      "solidity": "sol",
+      "proto": "proto",
+      "protobuf": "proto",
+      "rst": "rst",
+      "latex": "latex",
+      "tex": "latex"
+    },
+    "supported": [
+      "cpp", "go", "java", "js", "php", "proto", "python", "rst",
+      "ruby", "rust", "scala", "swift", "markdown", "latex", "html", "sol"
+    ],
+    "generic": [
+      "json", "yaml", "yml", "toml", "ini", "env", "xml", "csv",
+      "bash", "sh", "zsh", "fish", "powershell", "batch",
+      "css", "scss", "sass", "less",
+      "sql", "graphql", "gql",
+      "dockerfile", "makefile", "cmake", "gradle", "hcl", "terraform",
+      "gitignore", "vue"
+    ]
+  },
+  "fallbackExtensions": {
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".ini": "ini",
+    ".cfg": "ini",
+    ".conf": "ini",
+    ".env": "env",
+    ".md": "markdown",
+    ".markdown": "markdown",
+    ".rst": "rst",
+    ".tex": "latex",
+    ".ltx": "latex",
+    ".xml": "xml",
+    ".csv": "csv",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "bash",
+    ".fish": "fish",
+    ".ps1": "powershell",
+    ".bat": "batch",
+    ".cmd": "batch",
+    ".css": "css",
+    ".scss": "scss",
+    ".sass": "sass",
+    ".less": "less",
+    ".sql": "sql",
+    ".graphql": "graphql",
+    ".gql": "graphql",
+    ".proto": "proto",
+    ".sol": "solidity",
+    ".zig": "zig",
+    ".nim": "nim",
+    ".lua": "lua",
+    ".r": "r",
+    ".R": "r",
+    ".dart": "dart",
+    ".ex": "elixir",
+    ".exs": "elixir",
+    ".erl": "erlang",
+    ".hrl": "erlang",
+    ".hs": "haskell",
+    ".lhs": "haskell",
+    ".clj": "clojure",
+    ".cljs": "clojure",
+    ".cljc": "clojure",
+    ".lisp": "lisp",
+    ".el": "lisp",
+    ".vim": "vim",
+    ".tf": "terraform",
+    ".hcl": "hcl",
+    ".vue": "vue",
+    ".txt": "text",
+    ".log": "text"
+  },
+  "specialFilenames": {
+    "dockerfile": "dockerfile",
+    "makefile": "makefile",
+    "gnumakefile": "makefile",
+    "cmakelists.txt": "cmake",
+    ".gitignore": "gitignore",
+    ".dockerignore": "gitignore",
+    ".env": "env",
+    ".editorconfig": "ini",
+    ".prettierrc": "json",
+    ".eslintrc": "json",
+    "tsconfig.json": "json",
+    "package.json": "json",
+    "composer.json": "json",
+    "cargo.toml": "toml",
+    "pyproject.toml": "toml",
+    "gemfile": "ruby",
+    "rakefile": "ruby",
+    "podfile": "ruby"
+  },
+  "binaryExtensions": [
+    ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".webp", ".svg", ".tiff",
+    ".mp3", ".mp4", ".wav", ".avi", ".mov", ".mkv", ".flac", ".ogg",
+    ".zip", ".tar", ".gz", ".rar", ".7z", ".bz2",
+    ".exe", ".dll", ".so", ".dylib", ".bin", ".wasm",
+    ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx",
+    ".ttf", ".otf", ".woff", ".woff2", ".eot",
+    ".class", ".pyc", ".o", ".a", ".lib", ".node"
+  ]
+}

package/assets/queries/_javascript/highlights.scm

@@ -0,0 +1,36 @@
+; Function and method parameters
+;-------------------------------
+
+; Javascript and Typescript Treesitter grammars deviate when defining the
+; tree structure for parameters, so we need to address them in each specific
+; language instead of ecma.
+
+; (p)
+(formal_parameters 
+  (identifier) @variable.parameter)
+
+; (...p)
+(formal_parameters
+  (rest_pattern
+    (identifier) @variable.parameter))
+
+; ({ p })
+(formal_parameters
+  (object_pattern
+    (shorthand_property_identifier_pattern) @variable.parameter))
+
+; ({ a: p })
+(formal_parameters
+  (object_pattern
+    (pair_pattern
+      value: (identifier) @variable.parameter)))
+
+; ([ p ])
+(formal_parameters
+  (array_pattern
+    (identifier) @variable.parameter))
+
+; (p = 1)
+(formal_parameters
+  (assignment_pattern
+    left: (identifier) @variable.parameter))

package/assets/queries/_javascript/locals.scm

@@ -0,0 +1,14 @@
+; Definitions
+;------------
+; Javascript and Typescript Treesitter grammars deviate when defining the
+; tree structure for parameters, so we need to address them in each specific
+; language instead of ecma.
+
+; (i)
+(formal_parameters 
+  (identifier) @local.definition.variable.parameter)
+
+; (i = 1)
+(formal_parameters 
+  (assignment_pattern
+    left: (identifier) @local.definition.variable.parameter))

package/assets/queries/_javascript/tags.scm

@@ -0,0 +1,88 @@
+(
+  (comment)* @doc
+  .
+  (method_definition
+    name: (property_identifier) @name) @definition.method
+  (#not-eq? @name "constructor")
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.method)
+)
+
+(
+  (comment)* @doc
+  .
+  [
+    (class
+      name: (_) @name)
+    (class_declaration
+      name: (_) @name)
+  ] @definition.class
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.class)
+)
+
+(
+  (comment)* @doc
+  .
+  [
+    (function_expression
+      name: (identifier) @name)
+    (function_declaration
+      name: (identifier) @name)
+    (generator_function
+      name: (identifier) @name)
+    (generator_function_declaration
+      name: (identifier) @name)
+  ] @definition.function
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: [(arrow_function) (function_expression)]) @definition.function)
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (variable_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: [(arrow_function) (function_expression)]) @definition.function)
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(assignment_expression
+  left: [
+    (identifier) @name
+    (member_expression
+      property: (property_identifier) @name)
+  ]
+  right: [(arrow_function) (function_expression)]
+) @definition.function
+
+(pair
+  key: (property_identifier) @name
+  value: [(arrow_function) (function_expression)]) @definition.function
+
+(
+  (call_expression
+    function: (identifier) @name) @reference.call
+  (#not-match? @name "^(require)$")
+)
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @name)
+  arguments: (_) @reference.call)
+
+(new_expression
+  constructor: (_) @name) @reference.class

package/assets/queries/_jsx/highlights.scm

@@ -0,0 +1,43 @@
+; Punctuation
+; -----------
+
+; Handle attribute delimiter (<Component color="red"/>)
+(jsx_attribute "=" @punctuation.delimiter)
+
+; <Component>
+(jsx_opening_element ["<" ">"] @punctuation.bracket)
+
+; </Component>
+(jsx_closing_element ["</" ">"] @punctuation.bracket)
+
+; <Component />
+(jsx_self_closing_element ["<" "/>"] @punctuation.bracket)
+
+; Attributes
+; ----------
+
+(jsx_attribute (property_identifier) @attribute)
+
+; Opening elements
+; ----------------
+
+(jsx_opening_element (identifier) @tag)
+
+(jsx_opening_element ((identifier) @constructor
+ (#match? @constructor "^[A-Z]")))
+
+; Closing elements
+; ----------------
+
+(jsx_closing_element (identifier) @tag)
+
+(jsx_closing_element ((identifier) @constructor
+ (#match? @constructor "^[A-Z]")))
+
+; Self-closing elements
+; ---------------------
+
+(jsx_self_closing_element (identifier) @tag)
+
+(jsx_self_closing_element ((identifier) @constructor
+ (#match? @constructor "^[A-Z]")))

package/assets/queries/_jsx/indents.scm

@@ -0,0 +1,6 @@
+[
+  (jsx_element)
+  (jsx_self_closing_element)
+] @indent
+
+(parenthesized_expression) @indent

package/assets/queries/_jsx/textobjects.scm

@@ -0,0 +1,7 @@
+; See runtime/queries/ecma/README.md for more info.
+
+(jsx_self_closing_element) @xml-element.around @xml-element.inside
+
+(jsx_element (jsx_opening_element) (_)* @xml-element.inside (jsx_closing_element))
+
+(jsx_element) @xml-element.around

package/assets/queries/_typescript/highlights.scm

@@ -0,0 +1,148 @@
+; Namespaces
+; ----------
+
+(internal_module
+  [((identifier) @namespace) ((nested_identifier (identifier) @namespace))])
+
+(ambient_declaration "global" @namespace)
+
+; Parameters
+; ----------
+; Javascript and Typescript Treesitter grammars deviate when defining the
+; tree structure for parameters, so we need to address them in each specific
+; language instead of ecma.
+
+; (p: t)
+; (p: t = 1)
+(required_parameter 
+  (identifier) @variable.parameter)
+
+; (...p: t)
+(required_parameter
+  (rest_pattern
+    (identifier) @variable.parameter))
+
+; ({ p }: { p: t })
+(required_parameter
+  (object_pattern
+    (shorthand_property_identifier_pattern) @variable.parameter))
+
+; ({ a: p }: { a: t })
+(required_parameter
+  (object_pattern
+    (pair_pattern
+      value: (identifier) @variable.parameter)))
+
+; ([ p ]: t[])
+(required_parameter
+  (array_pattern
+    (identifier) @variable.parameter))
+
+; (p?: t)
+; (p?: t = 1) // Invalid but still possible to highlight.
+(optional_parameter 
+  (identifier) @variable.parameter)
+
+; (...p?: t) // Invalid but still possible to highlight.
+(optional_parameter
+  (rest_pattern
+    (identifier) @variable.parameter))
+
+; ({ p }: { p?: t})
+(optional_parameter
+  (object_pattern
+    (shorthand_property_identifier_pattern) @variable.parameter))
+
+; ({ a: p }: { a?: t })
+(optional_parameter
+  (object_pattern
+    (pair_pattern
+      value: (identifier) @variable.parameter)))
+
+; ([ p ]?: t[]) // Invalid but still possible to highlight.
+(optional_parameter
+  (array_pattern
+    (identifier) @variable.parameter))
+
+(public_field_definition) @punctuation.special
+(this_type) @variable.builtin
+(type_predicate) @keyword.operator
+
+; Punctuation
+; -----------
+
+[
+  ":"
+] @punctuation.delimiter
+
+(optional_parameter "?" @punctuation.special)
+(property_signature "?" @punctuation.special)
+
+(conditional_type ["?" ":"] @operator)
+(ternary_expression ["?" ":"] @operator)
+
+; Keywords
+; --------
+
+[
+  "abstract"
+  "declare"
+  "module"
+  "export"
+  "infer"
+  "implements"
+  "keyof"
+  "namespace"
+  "override"
+  "satisfies"
+] @keyword
+
+[
+  "type"
+  "interface"
+  "enum"
+] @keyword.storage.type
+
+[
+  "public"
+  "private"
+  "protected"
+  "readonly"
+] @keyword.storage.modifier
+
+; Types
+; -----
+
+(type_identifier) @type
+(type_parameter
+  name: (type_identifier) @type.parameter)
+(predefined_type) @type.builtin
+
+; Type arguments and parameters
+; -----------------------------
+
+(type_arguments
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(type_parameters
+  [
+    "<"
+    ">"
+  ] @punctuation.bracket)
+
+(omitting_type_annotation) @punctuation.special
+(opting_type_annotation) @punctuation.special
+
+; Literals
+; --------
+
+[
+  (template_literal_type)
+] @string
+
+(import_require_clause
+  (identifier) "="
+  ("require") @keyword)

package/assets/queries/_typescript/indents.scm

@@ -0,0 +1,5 @@
+[
+  (enum_declaration) 
+  (interface_declaration)
+  (object_type)
+] @indent

package/assets/queries/_typescript/locals.scm

@@ -0,0 +1,34 @@
+; Scopes
+;-------
+
+[
+  (type_alias_declaration)
+  (class_declaration)
+  (interface_declaration)
+] @local.scope
+
+; Definitions
+;------------
+
+(type_parameter
+  name: (type_identifier) @local.definition.type.parameter)
+
+; Javascript and Typescript Treesitter grammars deviate when defining the
+; tree structure for parameters, so we need to address them in each specific
+; language instead of ecma.
+
+; (i: t)
+; (i: t = 1)
+(required_parameter
+  (identifier) @local.definition.variable.parameter)
+
+; (i?: t)
+; (i?: t = 1) // Invalid but still possible to highlight.
+(optional_parameter
+  (identifier) @local.definition.variable.parameter)
+
+; References
+;-----------
+
+(type_identifier) @local.reference
+(identifier) @local.reference

package/assets/queries/_typescript/tags.scm

@@ -0,0 +1,23 @@
+(function_signature
+  name: (identifier) @name) @definition.function
+
+(method_signature
+  name: (property_identifier) @name) @definition.method
+
+(abstract_method_signature
+  name: (property_identifier) @name) @definition.method
+
+(abstract_class_declaration
+  name: (type_identifier) @name) @definition.class
+
+(module
+  name: (identifier) @name) @definition.module
+
+(interface_declaration
+  name: (type_identifier) @name) @definition.interface
+
+(type_annotation
+  (type_identifier) @name) @reference.type
+
+(new_expression
+  constructor: (identifier) @name) @reference.class

package/assets/queries/_typescript/textobjects.scm

@@ -0,0 +1,12 @@
+[
+  (interface_declaration 
+    body:(_) @class.inside)
+  (type_alias_declaration 
+    value: (_) @class.inside)
+] @class.around
+
+(enum_body
+  (_) @entry.around)
+
+(enum_assignment (_) @entry.inside)
+