coc-codeql 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nitrocao
+
+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/README.md

@@ -0,0 +1,146 @@
+# coc-codeql
+
+[CodeQL](https://codeql.github.com/) language support for
+[coc.nvim](https://github.com/neoclide/coc.nvim) — an editor companion
+to the CodeQL CLI, following the editing experience of the official
+[vscode-codeql](https://github.com/github/vscode-codeql) extension.
+
+## Features
+
+- **Language server integration** — diagnostics, completion, hover,
+  definition, references, document symbols, formatting, rename and
+  inlay hints, with pack resolution through the qlpack and the package
+  cache (`codeql pack install`)
+- **Filetype detection** for `*.ql` / `*.qll`
+- **Language configuration** — `//` line comments, block comment
+  continuation, comment-aware `formatoptions`
+- **Tree-sitter highlighting & folding**
+
+This extension is a pure editor integration: the language intelligence
+lives in the CodeQL CLI, the parser and highlight queries are provided
+by your editor's tree-sitter toolchain, and nothing is bundled here.
+
+## Requirements
+
+- neovim ≥ 0.9 (developed and tested on 0.12)
+- coc.nvim ≥ 0.0.82
+- the CodeQL CLI ≥ 2.x on `PATH` (or set `codeql.cliPath`)
+- the `ql` tree-sitter parser, installed through the tree-sitter
+  ecosystem:
+
+```vim
+:TSInstall ql
+```
+
+> nvim-treesitter registers the
+> [tree-sitter-ql](https://github.com/samlanning/tree-sitter-ql)
+> grammar and ships its queries. The revision currently pinned in
+> nvim-treesitter's lockfile mis-parses `true()`/`false()` (QL has no
+> boolean literals); if that bites you, install a fixed parser build
+> into your nvim site directory manually (`:h treesitter-parsers`).
+> Without a parser, highlighting degrades gracefully with a warning;
+> every other feature works.
+
+## Install
+
+```vim
+:CocInstall coc-codeql
+```
+
+## Configuration
+
+```jsonc
+{
+  // Path to the CodeQL CLI executable: a name resolved on PATH
+  // (default "codeql") or an absolute path. Resolved once at
+  // activation; if it cannot be found, a warning is shown and the
+  // language-server features are disabled (editor features remain).
+  // Changing it requires :CocRestart.
+  "codeql.cliPath": "codeql",
+
+  // Start the CodeQL language server at all. When false, no client and
+  // no commands are registered; filetype detection, language
+  // configuration and highlighting are unaffected.
+  "codeql.languageServer.enable": true,
+
+  // How the server checks for QL errors — passed as --check-errors.
+  //   "ON_CHANGE" (default): diagnostics are compiled and published
+  //     in the background as you edit (live diagnostics).
+  //   "EXPLICIT": the server runs no background checking and never
+  //     publishes diagnostics; useful to silence diagnostics on slow
+  //     machines or huge workspaces while keeping completion, hover
+  //     and definition. Despite the name, there is no way to request
+  //     checks on demand in the current protocol (verified against
+  //     CLI 2.27.0).
+  // Re-read whenever the server starts (activation or restart).
+  "codeql.languageServer.checkErrors": "ON_CHANGE"
+}
+```
+
+Commands:
+
+| Command | Effect |
+| --- | --- |
+| `:CocCommand codeql.restartLanguageServer` | Restart the language server (re-reads `checkErrors`). |
+
+Protocol details and semantics:
+[docs/language-server.md](docs/language-server.md).
+
+## Development
+
+```sh
+pnpm build        # esbuild → lib/index.js (also runs on pnpm install)
+pnpm watch        # rebuild on change
+pnpm typecheck    # tsc --noEmit for src and tests
+pnpm lint         # eslint — errors on any @deprecated API usage
+pnpm lint:md      # markdownlint over all markdown files
+pnpm check        # typecheck + lint + lint:md
+pnpm test         # test/*.test.ts — the feature suite (coc-test)
+pnpm test:variants # test/variants/* — configuration-variant suites
+pnpm test:all     # check + both test suites
+```
+
+The LSP suites skip when `codeql` is not on `PATH`. The highlighting
+suites that need a real parser skip when none is found; point
+`COC_CODEQL_PARSER_DIR` at a directory containing `parser/ql.so` and
+`queries/ql/` to provide one. `test:variants` injects settings before
+activation through `COC_CODEQL_SETTINGS`
+(see `scripts/test-setup.mjs`).
+
+## Roadmap
+
+Measured against vscode-codeql's feature set (query execution,
+database management, variant analysis, …), this extension currently
+implements the language-editing foundation. Plans:
+
+**Editing experience**
+
+- [x] Language server: diagnostics, completion, hover, definition,
+      references, document symbols, formatting, rename
+- [x] Syntax highlighting & folding (tree-sitter)
+- [x] Filetype detection and language configuration
+- [ ] Semantic tokens / richer highlighting from the server
+- [ ] Inlay hints exposure (the server supports them; coc wiring needed)
+
+**Query development**
+
+- [ ] Run query against the current database
+      (`codeql query run` / the query server)
+- [ ] Quick evaluation of the selected predicate/expressions
+- [ ] Results viewing (export to CSV/SARIF, a results buffer)
+- [ ] Query history
+- [ ] `.qltest` test running and output comparison
+
+**Database management**
+
+- [ ] Database selection UI (`:CocList`-style picker)
+- [ ] Database overview (language, upgrade hints)
+
+**Workspace & packs**
+
+- [ ] `codeql pack install` / dependency management commands
+- [ ] qlpack-aware workspace features (smart workspace detection)
+
+## License
+
+MIT

package/docs/language-server.md

@@ -0,0 +1,147 @@
+# CodeQL language server integration
+
+Reference for how coc-codeql drives `codeql execute language-server`.
+Facts below were established against CLI **2.27.0** by raw stdio
+JSON-RPC probing, by reading the shipped bytecode
+(`com.semmle.frontend.server.*` in `tools/codeql.jar`), and by the
+end-to-end tests in `test/`.
+
+## Server
+
+```sh
+codeql execute language-server --check-errors ON_CHANGE|EXPLICIT
+```
+
+- LSP over stdio (Content-Length framed JSON-RPC on stdin/stdout).
+- Older CLI releases used the subcommand `executeLanguageServer`.
+- `--search-path` exists but is not needed: the server discovers
+  qlpacks recursively under the workspace folders sent at
+  `initialize` and resolves dependencies through the pack cache
+  (`~/.codeql/packages`, populated by `codeql pack install`). Run
+  `codeql pack install` in your qlpack once.
+- `--synchronous` exists for debugging; not used here.
+
+### Capabilities (from `initialize`)
+
+| Capability | Notes |
+| --- | --- |
+| diagnostics | pushed on change (ON_CHANGE mode); qlpack.yml files get published too |
+| completion | trigger characters `.` and `,`; member + import completion |
+| hover | markdown; predicate signature + doc comment |
+| definition | jumps into the pack cache (`.qll` files) |
+| references / documentHighlight / documentSymbol | |
+| formatting (document + range) | |
+| rename (+ prepareRename) | |
+| inlayHint | |
+| signatureHelp, codeAction, codeLens | |
+| workspace folders | `supported: true, changeNotifications: true` |
+| experimental | `checkErrorsProvider`, `guessLocationProvider` (both advertised unconditionally; see below) |
+
+### Custom protocol surface
+
+Beyond standard LSP, the server speaks:
+
+- `textDocument/codeQLDidChangeVisibleFiles` (client → server,
+  notification) — sent by vscode-codeql when visible editors change.
+  **Not required**: diagnostics, completion, hover and definition all
+  work without it; not implemented here.
+- `semmle/workspace/guessLocation` (client → server, request) — used
+  by upstream to "guess the qlpack for this file"; not implemented
+  here.
+- `qlDidLoadConfiguration` (server → client, notification) — fired
+  after `workspace/didChangeConfiguration` is processed; carries
+  `ConfigurationLoadErrors`.
+
+The server dynamically registers `workspace/didChangeWatchedFiles`
+(requires the client to advertise the capability) and watches
+`qlpack.yml`, `codeql-pack.yml`, `codeql-workspace.yml`,
+`.codeqlmanifest.json`, `.dbscheme`, `*.ql`, `*.qll`.
+
+### Protocol requirements
+
+1. **`initialize.workspaceFolders` is mandatory.** With only `rootUri`,
+   every import fails with `could not resolve module …`. coc's
+   `LanguageClient` fills `workspaceFolders` from its workspace root
+   detection natively — nothing to do on our side.
+2. `initialize` must not be followed by an unknown-option spawn: the
+   CLI rejects any extra arguments (see the `--stdio` pitfall below).
+
+## Client wiring (src/lsp.ts)
+
+```ts
+const serverOptions: ServerOptions = async () => {
+  serverProcess?.kill()
+  serverProcess = spawnChild(cli, serverArgs())   // re-reads configuration
+  return serverProcess
+}
+
+const clientOptions: LanguageClientOptions = {
+  documentSelector: [
+    { language: 'ql', scheme: 'file' },
+    { language: 'yaml', scheme: 'file', pattern: '**/qlpack.yml' },
+    { language: 'yaml', scheme: 'file', pattern: '**/codeql-pack.yml' },
+    { language: 'yaml', scheme: 'file', pattern: '**/codeql-workspace.yml' },
+  ],
+  outputChannelName: 'codeql',
+}
+```
+
+Design notes:
+
+- **Function-form `ServerOptions`.** The extension spawns the server
+  itself on every start. The static `{ command, args }` form has two
+  problems: coc appends `--stdio` for explicit stdio transports, which
+  the codeql CLI rejects (`Unknown option: '--stdio'`, crash-looping
+  the client); and static args would be frozen at activation, so
+  `codeql.languageServer.checkErrors` could never take effect across a
+  restart. The function form avoids both; coc consumes the child's
+  stdin/stdout directly. The child is killed on disposal.
+- **documentSelector** matches vscode-codeql's, plus
+  `**/codeql-workspace.yml` (upstream lists only qlpack.yml and
+  codeql-pack.yml).
+- The server is spawned eagerly at activation. coc's service-wrapper
+  state shown in `:CocList services` still reads `initial` until the
+  first matching buffer opens — a display quirk of coc, not the actual
+  process state.
+
+## Configuration semantics
+
+- `codeql.cliPath` — `"codeql"` (default) or a path. Resolved via
+  `exepath` once at activation; if missing, a warning is shown and the
+  LSP features are disabled (editor features remain). Changing it
+  requires `:CocRestart`.
+- `codeql.languageServer.enable` — `true` (default) / `false`. When
+  `false`, no client and no commands are registered; editor features
+  remain. Read at activation.
+- `codeql.languageServer.checkErrors` — `"ON_CHANGE"` (default) /
+  `"EXPLICIT"`, passed as `--check-errors`. Re-read on every server
+  start (activation and `codeql.restartLanguageServer`); see below.
+
+### `checkErrors` — what the values actually do
+
+Established from the CLI bytecode and covered by
+`test/explicit-mode.test.ts`:
+
+- `ON_CHANGE` — the server constructs an `AsynchronousDiagnosticReporter`
+  that compiles changed QL files in the background and pushes
+  `textDocument/publishDiagnostics`. Live diagnostics.
+- `EXPLICIT` — the reporter is never created, and **no diagnostics are
+  published at all**. Despite the advertised
+  `experimental.checkErrorsProvider: true` capability, this protocol
+  generation has no request that triggers checks on demand — the flag
+  is vestigial. Practical use: silence diagnostics on slow machines or
+  huge workspaces while keeping completion/hover/definition (those
+  still compile on demand).
+
+## Commands
+
+| Command | Effect |
+| --- | --- |
+| `codeql.restartLanguageServer` | Stop + start the server; re-reads `checkErrors`. |
+
+## Out of scope
+
+- Query execution, quick evaluation, results/BQRS inspection — the
+  *query server* (`codeql execute query-server2`), a separate JSON-RPC
+  protocol, not LSP.
+- `.qltest` running and test-output acceptance.

package/lib/index.js

@@ -0,0 +1,134 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  activate: () => activate
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_coc2 = require("coc.nvim");
+
+// src/lsp.ts
+var import_node_child_process = require("node:child_process");
+var import_coc = require("coc.nvim");
+async function resolveCli() {
+  const config = import_coc.workspace.getConfiguration("codeql");
+  const cliPath = config.get("cliPath", "codeql");
+  const resolved = await import_coc.workspace.nvim.call("exepath", [cliPath]);
+  return resolved === "" ? void 0 : resolved;
+}
+function serverArgs() {
+  const config = import_coc.workspace.getConfiguration("codeql");
+  const checkErrors = config.get(
+    "languageServer.checkErrors",
+    "ON_CHANGE"
+  );
+  return ["execute", "language-server", "--check-errors", checkErrors];
+}
+async function registerLanguageServer(context) {
+  const cli = await resolveCli();
+  if (!cli) {
+    void import_coc.window.showWarningMessage(
+      '[coc-codeql] codeql CLI not found; set "codeql.cliPath". LSP features are disabled.'
+    );
+    return;
+  }
+  let serverProcess;
+  const serverOptions = async () => {
+    serverProcess?.kill();
+    serverProcess = (0, import_node_child_process.spawn)(cli, serverArgs());
+    return serverProcess;
+  };
+  const clientOptions = {
+    documentSelector: [
+      { language: "ql", scheme: "file" },
+      { language: "yaml", scheme: "file", pattern: "**/qlpack.yml" },
+      { language: "yaml", scheme: "file", pattern: "**/codeql-pack.yml" },
+      { language: "yaml", scheme: "file", pattern: "**/codeql-workspace.yml" }
+    ],
+    outputChannelName: "codeql"
+  };
+  const client = new import_coc.LanguageClient(
+    "codeql",
+    "CodeQL Language Server",
+    serverOptions,
+    clientOptions
+  );
+  context.subscriptions.push(import_coc.services.registerLanguageClient(client));
+  context.subscriptions.push({
+    dispose: () => serverProcess?.kill()
+  });
+  await client.start();
+  context.subscriptions.push(
+    import_coc.commands.registerCommand(
+      "codeql.restartLanguageServer",
+      async () => {
+        await client.stop();
+        await client.start();
+        void import_coc.window.showInformationMessage(
+          "[coc-codeql] language server restarted"
+        );
+      }
+    )
+  );
+}
+
+// src/index.ts
+async function activate(context) {
+  const { nvim } = import_coc2.workspace;
+  await nvim.call("nvim_set_var", [
+    "coc_codeql_lua_path",
+    import_node_path.default.join(context.extensionPath, "lua", "codeql.lua")
+  ]);
+  await nvim.call("nvim_exec2", [
+    "lua local m = dofile(vim.g.coc_codeql_lua_path) ; _G.coc_codeql = m ; m.setup()",
+    { output: false }
+  ]);
+  const enabled = import_coc2.workspace.getConfiguration("codeql").get("languageServer.enable", true);
+  if (enabled) {
+    await registerLanguageServer(context);
+  }
+  const parserWarning = setTimeout(() => {
+    void import_coc2.workspace.nvim.getVar("coc_codeql_parser_error").then((error) => {
+      if (typeof error === "string" && error.length > 0) {
+        void import_coc2.window.showWarningMessage(
+          `[coc-codeql] tree-sitter parser for ql not available (${error}). Install it with \`:TSInstall ql\` (nvim-treesitter) or see :h treesitter-parsers.`
+        );
+      }
+    }).catch(() => {
+    });
+  }, 3e3);
+  context.subscriptions.push({ dispose: () => clearTimeout(parserWarning) });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activate
+});

package/lua/codeql.lua

@@ -0,0 +1,93 @@
+--- CodeQL runtime support for coc-codeql.
+---
+--- This extension is pure editor integration: it provides filetype
+--- detection, the language configuration and starts tree-sitter
+--- highlighting. The parser itself is NOT bundled — that is the job of
+--- the tree-sitter ecosystem:
+---
+---   :TSInstall ql   (nvim-treesitter registers the tree-sitter-ql
+---                    grammar and ships its queries)
+---
+--- or a manual install, see :h treesitter-parsers.
+---
+--- Loaded by the coc extension through dofile() and exposed as the
+--- global `coc_codeql` (setup() is idempotent, so it can be re-run).
+
+local M = {}
+
+local GROUP = 'coc_codeql'
+
+local function start_highlight(buf)
+  -- nvim-treesitter's highlight module may already have started
+  if vim.treesitter.highlighter.active[buf] then
+    return
+  end
+  local ok, err = pcall(vim.treesitter.start, buf, 'ql')
+  if not ok then
+    -- No notifying from lua: vim.notify is hooked by coc.nvim into a
+    -- synchronous RPC handler, and any editor output from a scheduled
+    -- callback can wedge the RPC channel of embedded editors. Record the
+    -- failure; the extension's node side picks it up and warns through
+    -- coc's own message channel.
+    _G.coc_codeql_parser_error = tostring(err):gsub('\n.*', '')
+  end
+end
+
+local function on_filetype(buf)
+  if vim.bo[buf].buftype ~= '' then
+    return
+  end
+
+  --- language configuration (was language-configuration.json in the
+  --- vscode extension): line comments, comment continuation, auto-wrap
+  vim.bo[buf].commentstring = '// %s'
+  vim.bo[buf].comments = 'sO:*. -,mO:*.  ,exO:*/,s1:/*,mb:*,ex:*/,://'
+  local fo = vim.bo[buf].formatoptions:gsub('t', '')
+  for _, flag in ipairs({ 'c', 'r', 'o', 'q', 'l' }) do
+    if not fo:find(flag, 1, true) then
+      fo = fo .. flag
+    end
+  end
+  vim.bo[buf].formatoptions = fo
+
+  -- Started from a timer: launching the highlighter inside the
+  -- FileType autocmd wedges nvim's embed channel (see test notes).
+  vim.fn.timer_start(50, function() start_highlight(buf) end)
+end
+
+function M.setup()
+  local group = vim.api.nvim_create_augroup(GROUP, { clear = true })
+
+  -- filetype detection: nvim has no built-in detection for CodeQL
+  vim.api.nvim_create_autocmd({ 'BufReadPost', 'BufNewFile' }, {
+    group = group,
+    pattern = { '*.ql', '*.qll' },
+    callback = function(args)
+      if vim.bo[args.buf].filetype == '' then
+        vim.bo[args.buf].filetype = 'ql' -- fires FileType below
+      end
+    end,
+  })
+
+  vim.api.nvim_create_autocmd('FileType', {
+    group = group,
+    pattern = 'ql',
+    callback = function(args)
+      on_filetype(args.buf)
+    end,
+  })
+
+  -- fix up buffers that were loaded before setup() ran
+  for _, buf in ipairs(vim.api.nvim_list_bufs()) do
+    if vim.api.nvim_buf_is_loaded(buf) and vim.bo[buf].buftype == '' then
+      local name = vim.api.nvim_buf_get_name(buf)
+      if vim.bo[buf].filetype == '' and name:match('%.qll?$') then
+        vim.bo[buf].filetype = 'ql'
+      elseif vim.bo[buf].filetype == 'ql' then
+        on_filetype(buf)
+      end
+    end
+  end
+end
+
+return M

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "coc-codeql",
+  "version": "0.1.0",
+  "description": "CodeQL language support for coc.nvim: language server integration, filetype detection and tree-sitter highlighting",
+  "main": "lib/index.js",
+  "keywords": [
+    "coc",
+    "coc.nvim",
+    "codeql",
+    "ql",
+    "tree-sitter",
+    "highlight"
+  ],
+  "engines": {
+    "coc": ">=0.0.82"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NitroCao/coc-codeql.git"
+  },
+  "homepage": "https://github.com/NitroCao/coc-codeql#readme",
+  "bugs": "https://github.com/NitroCao/coc-codeql/issues",
+  "packageManager": "pnpm@12.5.1",
+  "activationEvents": [
+    "*"
+  ],
+  "coc-test": {
+    "entryFile": "src/index.ts",
+    "setup": "scripts/test-setup.mjs"
+  },
+  "contributes": {
+    "configuration": {
+      "title": "CodeQL",
+      "properties": {
+        "codeql.cliPath": {
+          "type": "string",
+          "default": "codeql",
+          "description": "Path to the CodeQL CLI executable."
+        },
+        "codeql.languageServer.enable": {
+          "type": "boolean",
+          "default": true,
+          "description": "Start the CodeQL language server (diagnostics, completion, hover, definition)."
+        },
+        "codeql.languageServer.checkErrors": {
+          "type": "string",
+          "enum": [
+            "ON_CHANGE",
+            "EXPLICIT"
+          ],
+          "default": "ON_CHANGE",
+          "description": "When to check for QL errors."
+        }
+      }
+    },
+    "commands": [
+      {
+        "title": "Restart the CodeQL language server",
+        "command": "codeql.restartLanguageServer"
+      }
+    ]
+  },
+  "scripts": {
+    "build": "node esbuild.mjs",
+    "watch": "node esbuild.mjs --watch",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.test.json",
+    "lint": "eslint .",
+    "lint:md": "markdownlint-cli2 '**/*.md' '#node_modules' '#.claude'",
+    "check": "pnpm typecheck && pnpm lint && pnpm lint:md",
+    "test": "coc-test 'test/*.test.ts'",
+    "test:variants": "COC_CODEQL_SETTINGS='{\"codeql\":{\"languageServer\":{\"enable\":false}}}' coc-test 'test/variants/no-language-server.test.ts' && COC_CODEQL_SETTINGS='{\"codeql\":{\"cliPath\":\"/nonexistent/codeql\"}}' coc-test 'test/variants/cli-not-found.test.ts'",
+    "test:all": "pnpm check && pnpm test && pnpm test:variants",
+    "clean": "node -e \"require('fs').rmSync('lib',{recursive:true,force:true})\"",
+    "prepare": "node esbuild.mjs"
+  },
+  "author": "nitrocao",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "coc-test": "^0.2.0",
+    "coc.nvim": "^0.0.83-next.9",
+    "esbuild": "^0.24.2",
+    "eslint": "^9.39.5",
+    "markdownlint-cli2": "^0.23.3",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.70.1"
+  },
+  "files": [
+    "lib",
+    "lua",
+    "docs",
+    "README.md",
+    "LICENSE"
+  ]
+}