@danielblomma/cortex-mcp 1.3.2 → 1.4.0

package/scaffold/scripts/parsers/node_modules/tree-sitter-wasms/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "tree-sitter-wasms",
+  "version": "0.1.13",
+  "description": "Prebuilt WASM binaries for tree-sitter's language parsers.",
+  "repository": "https://github.com/Gregoor/tree-sitter-wasms",
+  "author": "Gregor <gregorwbr@gmail.com>, Menci <huanghaorui301@gmail.com>",
+  "license": "Unlicense",
+  "scripts": {
+    "build": "ts-node build.ts"
+  },
+  "devDependencies": {
+    "@supercharge/promise-pool": "^3.1.1",
+    "@tlaplus/tree-sitter-tlaplus": "^1.2.4",
+    "@tree-sitter-grammars/tree-sitter-zig": "^1.0.0",
+    "@types/find-root": "^1.1.4",
+    "@types/node": "^20.11.17",
+    "@willjouo/tree-sitter-r": "^0.0.1",
+    "find-root": "^1.1.0",
+    "tree-sitter-bash": "^0.20.5",
+    "tree-sitter-c": "^0.20.7",
+    "tree-sitter-c-sharp": "^0.20.0",
+    "tree-sitter-cli": "^0.20.8",
+    "tree-sitter-cpp": "^0.20.4",
+    "tree-sitter-css": "^0.20.0",
+    "tree-sitter-dart": "github:UserNobody14/tree-sitter-dart",
+    "tree-sitter-elisp": "^1.3.0",
+    "tree-sitter-elixir": "^0.1.1",
+    "tree-sitter-elm": "^4.5.0",
+    "tree-sitter-embedded-template": "^0.20.0",
+    "tree-sitter-go": "^0.20.0",
+    "tree-sitter-html": "^0.20.0",
+    "tree-sitter-java": "^0.20.2",
+    "tree-sitter-javascript": "^0.20.3",
+    "tree-sitter-json": "^0.20.2",
+    "tree-sitter-kotlin": "^0.3.1",
+    "tree-sitter-lua": "^2.1.3",
+    "tree-sitter-objc": "^2.1.0",
+    "tree-sitter-ocaml": "^0.20.4",
+    "tree-sitter-php": "^0.22.0",
+    "tree-sitter-python": "^0.21.0",
+    "tree-sitter-ql": "^1.0.0",
+    "tree-sitter-rescript": "github:rescript-lang/tree-sitter-rescript#6376fa028f31aa4e26ca2c8f007e322cd2a5eb4a",
+    "tree-sitter-ruby": "^0.20.1",
+    "tree-sitter-rust": "^0.20.4",
+    "tree-sitter-scala": "^0.19.0",
+    "tree-sitter-solidity": "github:JoranHonig/tree-sitter-solidity#b239a95f94cfcc6e7b3e961bc73a28d55e214f02",
+    "tree-sitter-swift": "^0.4.0",
+    "tree-sitter-systemrdl": "^0.7.0",
+    "tree-sitter-toml": "^0.5.1",
+    "tree-sitter-typescript": "^0.20.5",
+    "tree-sitter-vue": "https://github.com/tree-sitter-grammars/tree-sitter-vue#7e48557b903a9db9c38cea3b7839ef7e1f36c693",
+    "tree-sitter-yaml": "^0.5.0",
+    "ts-node": "^10.9.2",
+    "typescript": "5.3.3"
+  },
+  "files": [
+    "/out"
+  ],
+  "packageManager": "pnpm@8.10.5",
+  "main": "bindings/node",
+  "dependencies": {
+    "tree-sitter-wasms": "^0.1.11"
+  }
+}

package/scaffold/scripts/parsers/node_modules/web-tree-sitter/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-2024 Max Brunsfeld
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/scaffold/scripts/parsers/node_modules/web-tree-sitter/README.md

@@ -0,0 +1,198 @@
+# Web Tree-sitter
+
+[![npmjs.com badge]][npmjs.com]
+
+[npmjs.com]: https://www.npmjs.org/package/web-tree-sitter
+[npmjs.com badge]: https://img.shields.io/npm/v/web-tree-sitter.svg?color=%23BF4A4A
+
+WebAssembly bindings to the [Tree-sitter](https://github.com/tree-sitter/tree-sitter) parsing library.
+
+### Setup
+
+You can download the `tree-sitter.js` and `tree-sitter.wasm` files from [the latest GitHub release](https://github.com/tree-sitter/tree-sitter/releases/latest) and load them using a standalone script:
+
+```html
+<script src="/the/path/to/tree-sitter.js"></script>
+
+<script>
+  const Parser = window.TreeSitter;
+  Parser.init().then(() => { /* the library is ready */ });
+</script>
+```
+
+You can also install [the `web-tree-sitter` module](https://www.npmjs.com/package/web-tree-sitter) from NPM and load it using a system like Webpack:
+
+```js
+const Parser = require('web-tree-sitter');
+Parser.init().then(() => { /* the library is ready */ });
+```
+
+You can use this module with [deno](https://deno.land/):
+
+```js
+import Parser from "npm:web-tree-sitter";
+await Parser.init();
+// the library is ready
+```
+
+### Basic Usage
+
+First, create a parser:
+
+```js
+const parser = new Parser;
+```
+
+Then assign a language to the parser. Tree-sitter languages are packaged as individual `.wasm` files (more on this below):
+
+```js
+const JavaScript = await Parser.Language.load('/path/to/tree-sitter-javascript.wasm');
+parser.setLanguage(JavaScript);
+```
+
+Now you can parse source code:
+
+```js
+const sourceCode = 'let x = 1; console.log(x);';
+const tree = parser.parse(sourceCode);
+```
+
+and inspect the syntax tree.
+
+```javascript
+console.log(tree.rootNode.toString());
+
+// (program
+//   (lexical_declaration
+//     (variable_declarator (identifier) (number)))
+//   (expression_statement
+//     (call_expression
+//       (member_expression (identifier) (property_identifier))
+//       (arguments (identifier)))))
+
+const callExpression = tree.rootNode.child(1).firstChild;
+console.log(callExpression);
+
+// { type: 'call_expression',
+//   startPosition: {row: 0, column: 16},
+//   endPosition: {row: 0, column: 30},
+//   startIndex: 0,
+//   endIndex: 30 }
+```
+
+### Editing
+
+If your source code *changes*, you can update the syntax tree. This will take less time than the first parse.
+
+```javascript
+// Replace 'let' with 'const'
+const newSourceCode = 'const x = 1; console.log(x);';
+
+tree.edit({
+  startIndex: 0,
+  oldEndIndex: 3,
+  newEndIndex: 5,
+  startPosition: {row: 0, column: 0},
+  oldEndPosition: {row: 0, column: 3},
+  newEndPosition: {row: 0, column: 5},
+});
+
+const newTree = parser.parse(newSourceCode, tree);
+```
+
+### Parsing Text From a Custom Data Structure
+
+If your text is stored in a data structure other than a single string, you can parse it by supplying a callback to `parse` instead of a string:
+
+```javascript
+const sourceLines = [
+  'let x = 1;',
+  'console.log(x);'
+];
+
+const tree = parser.parse((index, position) => {
+  let line = sourceLines[position.row];
+  if (line) return line.slice(position.column);
+});
+```
+
+### Generate .wasm language files
+
+The following example shows how to generate `.wasm` file for tree-sitter JavaScript grammar.
+
+**IMPORTANT**: [emscripten](https://emscripten.org/docs/getting_started/downloads.html), [docker](https://www.docker.com/), or [podman](https://podman.io) need to be installed.
+
+First install `tree-sitter-cli` and the tree-sitter language for which to generate `.wasm` (`tree-sitter-javascript` in this example):
+
+```sh
+npm install --save-dev tree-sitter-cli tree-sitter-javascript
+```
+
+Then just use tree-sitter cli tool to generate the `.wasm`.
+
+```sh
+npx tree-sitter build --wasm node_modules/tree-sitter-javascript
+```
+
+If everything is fine, file `tree-sitter-javascript.wasm` should be generated in current directory.
+
+#### Running .wasm in Node.js
+
+Notice that executing `.wasm` files in node.js is considerably slower than running [node.js bindings](https://github.com/tree-sitter/node-tree-sitter). However could be useful for testing purposes:
+
+```javascript
+const Parser = require('web-tree-sitter');
+
+(async () => {
+  await Parser.init();
+  const parser = new Parser();
+  const Lang = await Parser.Language.load('tree-sitter-javascript.wasm');
+  parser.setLanguage(Lang);
+  const tree = parser.parse('let x = 1;');
+  console.log(tree.rootNode.toString());
+})();
+```
+
+#### Running .wasm in browser
+
+`web-tree-sitter` can run in the browser, but there are some common pitfalls.
+
+##### Loading the .wasm file
+
+`web-tree-sitter` needs to load the `tree-sitter.wasm` file. By default, it assumes that this file is available in the
+same path as the JavaScript code. Therefore, if the code is being served from `http://localhost:3000/bundle.js`, then
+the wasm file should be at `http://localhost:3000/tree-sitter.wasm`.
+
+For server side frameworks like NextJS, this can be tricky as pages are often served from a path such as
+`http://localhost:3000/_next/static/chunks/pages/index.js`. The loader will therefore look for the wasm file at
+`http://localhost:3000/_next/static/chunks/pages/tree-sitter.wasm`. The solution is to pass a `locateFile` function in
+the `moduleOptions` argument to `Parser.init()`:
+
+```javascript
+await Parser.init({
+  locateFile(scriptName: string, scriptDirectory: string) {
+    return scriptName;
+  },
+});
+```
+
+`locateFile` takes in two parameters, `scriptName`, i.e. the wasm file name, and `scriptDirectory`, i.e. the directory
+where the loader expects the script to be. It returns the path where the loader will look for the wasm file. In the NextJS
+case, we want to return just the `scriptName` so that the loader will look at `http://localhost:3000/tree-sitter.wasm`
+and not `http://localhost:3000/_next/static/chunks/pages/tree-sitter.wasm`.
+
+##### `Can't resolve 'fs' in 'node_modules/web-tree-sitter'`
+
+Most bundlers will notice that the `tree-sitter.js` file is attempting to import `fs`, i.e. node's file system library.
+Since this doesn't exist in the browser, the bundlers will get confused. For webpack you can fix this by adding the
+following to your webpack config:
+
+```javascript
+{
+  resolve: {
+    fallback: {
+      fs: false
+    }
+  }
+}
+```

package/scaffold/scripts/parsers/node_modules/web-tree-sitter/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "web-tree-sitter",
+  "version": "0.22.6",
+  "description": "Tree-sitter bindings for the web",
+  "main": "tree-sitter.js",
+  "types": "tree-sitter-web.d.ts",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "mocha",
+    "prepack": "cp ../../LICENSE .",
+    "prepublishOnly": "node check-artifacts-fresh.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tree-sitter/tree-sitter.git"
+  },
+  "keywords": [
+    "incremental",
+    "parsing"
+  ],
+  "author": "Max Brunsfeld",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/tree-sitter/tree-sitter/issues"
+  },
+  "homepage": "https://github.com/tree-sitter/tree-sitter/tree/master/lib/binding_web",
+  "devDependencies": {
+    "@types/emscripten": "^1.39.10",
+    "chai": "^4.3.7",
+    "eslint": ">=8.56.0",
+    "eslint-config-google": "^0.14.0",
+    "mocha": "^10.2.0",
+    "terser": "^5.16.6"
+  }
+}

package/scaffold/scripts/parsers/node_modules/web-tree-sitter/tree-sitter-web.d.ts

@@ -0,0 +1,242 @@
+declare module 'web-tree-sitter' {
+  class Parser {
+    /**
+     *
+     * @param moduleOptions Optional emscripten module-object, see https://emscripten.org/docs/api_reference/module.html
+     */
+    static init(moduleOptions?: object): Promise<void>;
+    delete(): void;
+    parse(input: string | Parser.Input, oldTree?: Parser.Tree, options?: Parser.Options): Parser.Tree;
+    getIncludedRanges(): Parser.Range[];
+    getTimeoutMicros(): number;
+    setTimeoutMicros(timeout: number): void;
+    reset(): void;
+    getLanguage(): Parser.Language;
+    setLanguage(language?: Parser.Language | null): void;
+    getLogger(): Parser.Logger;
+    setLogger(logFunc?: Parser.Logger | false | null): void;
+  }
+
+  namespace Parser {
+    export type Options = {
+      includedRanges?: Range[];
+    };
+
+    export type Point = {
+      row: number;
+      column: number;
+    };
+
+    export type Range = {
+      startIndex: number,
+      endIndex: number,
+      startPosition: Point,
+      endPosition: Point
+    };
+
+    export type Edit = {
+      startIndex: number;
+      oldEndIndex: number;
+      newEndIndex: number;
+      startPosition: Point;
+      oldEndPosition: Point;
+      newEndPosition: Point;
+    };
+
+    export type Logger = (
+      message: string,
+      params: { [param: string]: string },
+      type: "parse" | "lex"
+    ) => void;
+
+    export interface Input {
+      (index: number, position?: Point): string | null;
+    }
+
+    export interface SyntaxNode {
+      tree: Tree;
+      id: number;
+      typeId: number;
+      grammarId: number;
+      type: string;
+      grammarType: string;
+      isNamed: boolean;
+      isMissing: boolean;
+      isExtra: boolean;
+      hasChanges: boolean;
+      hasError: boolean;
+      isError: boolean;
+      text: string;
+      parseState: number;
+      nextParseState: number;
+      startPosition: Point;
+      endPosition: Point;
+      startIndex: number;
+      endIndex: number;
+      parent: SyntaxNode | null;
+      children: Array<SyntaxNode>;
+      namedChildren: Array<SyntaxNode>;
+      childCount: number;
+      namedChildCount: number;
+      firstChild: SyntaxNode | null;
+      firstNamedChild: SyntaxNode | null;
+      lastChild: SyntaxNode | null;
+      lastNamedChild: SyntaxNode | null;
+      nextSibling: SyntaxNode | null;
+      nextNamedSibling: SyntaxNode | null;
+      previousSibling: SyntaxNode | null;
+      previousNamedSibling: SyntaxNode | null;
+      descendantCount: number;
+
+      equals(other: SyntaxNode): boolean;
+      toString(): string;
+      child(index: number): SyntaxNode | null;
+      namedChild(index: number): SyntaxNode | null;
+      childForFieldName(fieldName: string): SyntaxNode | null;
+      childForFieldId(fieldId: number): SyntaxNode | null;
+      fieldNameForChild(childIndex: number): string | null;
+      childrenForFieldName(fieldName: string): Array<SyntaxNode>;
+      childrenForFieldId(fieldId: number): Array<SyntaxNode>;
+      firstChildForIndex(index: number): SyntaxNode | null;
+      firstNamedChildForIndex(index: number): SyntaxNode | null;
+
+      descendantForIndex(index: number): SyntaxNode;
+      descendantForIndex(startIndex: number, endIndex: number): SyntaxNode;
+      namedDescendantForIndex(index: number): SyntaxNode;
+      namedDescendantForIndex(startIndex: number, endIndex: number): SyntaxNode;
+      descendantForPosition(position: Point): SyntaxNode;
+      descendantForPosition(startPosition: Point, endPosition: Point): SyntaxNode;
+      namedDescendantForPosition(position: Point): SyntaxNode;
+      namedDescendantForPosition(startPosition: Point, endPosition: Point): SyntaxNode;
+      descendantsOfType(types: String | Array<String>, startPosition?: Point, endPosition?: Point): Array<SyntaxNode>;
+
+      walk(): TreeCursor;
+    }
+
+    export interface TreeCursor {
+      nodeType: string;
+      nodeTypeId: number;
+      nodeStateId: number;
+      nodeText: string;
+      nodeId: number;
+      nodeIsNamed: boolean;
+      nodeIsMissing: boolean;
+      startPosition: Point;
+      endPosition: Point;
+      startIndex: number;
+      endIndex: number;
+      readonly currentNode: SyntaxNode;
+      readonly currentFieldName: string;
+      readonly currentFieldId: number;
+      readonly currentDepth: number;
+      readonly currentDescendantIndex: number;
+
+      reset(node: SyntaxNode): void;
+      resetTo(cursor: TreeCursor): void;
+      delete(): void;
+      gotoParent(): boolean;
+      gotoFirstChild(): boolean;
+      gotoLastChild(): boolean;
+      gotoFirstChildForIndex(goalIndex: number): boolean;
+      gotoFirstChildForPosition(goalPosition: Point): boolean;
+      gotoNextSibling(): boolean;
+      gotoPreviousSibling(): boolean;
+      gotoDescendant(goalDescendantIndex: number): void;
+    }
+
+    export interface Tree {
+      readonly rootNode: SyntaxNode;
+
+      rootNodeWithOffset(offsetBytes: number, offsetExtent: Point): SyntaxNode;
+      copy(): Tree;
+      delete(): void;
+      edit(edit: Edit): Tree;
+      walk(): TreeCursor;
+      getChangedRanges(other: Tree): Range[];
+      getIncludedRanges(): Range[];
+      getEditedRange(other: Tree): Range;
+      getLanguage(): Language;
+    }
+
+    export interface QueryCapture {
+      name: string;
+      text?: string;
+      node: SyntaxNode;
+      setProperties?: { [prop: string]: string | null };
+      assertedProperties?: { [prop: string]: string | null };
+      refutedProperties?: { [prop: string]: string | null };
+    }
+
+    export interface QueryMatch {
+      pattern: number;
+      captures: QueryCapture[];
+    }
+
+    export type QueryOptions = {
+      startPosition?: Point;
+      endPosition?: Point;
+      startIndex?: number;
+      endIndex?: number;
+      matchLimit?: number;
+      maxStartDepth?: number;
+    };
+
+    export interface PredicateResult {
+      operator: string;
+      operands: { name: string; type: string }[];
+    }
+
+    export class Query {
+      captureNames: string[];
+      readonly predicates: { [name: string]: Function }[];
+      readonly setProperties: any[];
+      readonly assertedProperties: any[];
+      readonly refutedProperties: any[];
+      readonly matchLimit: number;
+
+      delete(): void;
+      captures(node: SyntaxNode, options?: QueryOptions): QueryCapture[];
+      matches(node: SyntaxNode, options?: QueryOptions): QueryMatch[];
+      predicatesForPattern(patternIndex: number): PredicateResult[];
+      disableCapture(captureName: string): void;
+      disablePattern(patternIndex: number): void;
+      isPatternGuaranteedAtStep(byteOffset: number): boolean;
+      isPatternRooted(patternIndex: number): boolean;
+      isPatternNonLocal(patternIndex: number): boolean;
+      startIndexForPattern(patternIndex: number): number;
+      didExceedMatchLimit(): boolean;
+    }
+
+    class Language {
+      static load(input: string | Uint8Array): Promise<Language>;
+
+      readonly version: number;
+      readonly fieldCount: number;
+      readonly stateCount: number;
+      readonly nodeTypeCount: number;
+
+      fieldNameForId(fieldId: number): string | null;
+      fieldIdForName(fieldName: string): number | null;
+      idForNodeType(type: string, named: boolean): number;
+      nodeTypeForId(typeId: number): string | null;
+      nodeTypeIsNamed(typeId: number): boolean;
+      nodeTypeIsVisible(typeId: number): boolean;
+      nextState(stateId: number, typeId: number): number;
+      query(source: string): Query;
+      lookaheadIterator(stateId: number): LookaheadIterable | null;
+    }
+
+    export class LookaheadIterable {
+      readonly language: Language;
+      readonly currentTypeId: number;
+      readonly currentType: string;
+
+      delete(): void;
+      reset(language: Language, stateId: number): boolean;
+      resetState(stateId: number): boolean;
+      [Symbol.iterator](): Iterator<string>;
+    }
+  }
+
+  export = Parser
+}