rapydscript-ng 0.7.23 → 0.8.0

package/editor-plugins/nvim/rapydscript/lua/rapydscript/init.lua

@@ -0,0 +1,279 @@
+local M = {}
+
+-- init.lua lives at <plugin>/lua/rapydscript/init.lua; 3 :h steps reach <plugin>/.
+local _plugin_root = vim.fn.fnamemodify(
+    debug.getinfo(1, "S").source:sub(2), ":p:h:h:h"
+)
+-- <plugin> is at <repo>/editor-plugins/nvim/rapydscript; 3 more :h steps reach <repo>/.
+local _repo_root = vim.fn.fnamemodify(_plugin_root, ":h:h:h")
+
+-- Compile the tree-sitter parser once per nvim instance at require() time.
+-- Stores the .so/.dll path on success, nil if sources are absent or compilation fails.
+local _ts_so = (function()
+    local ts_src = _repo_root .. "/tree-sitter/src"
+    local parser_c = ts_src .. "/parser.c"
+    local scanner_c = ts_src .. "/scanner.c"
+    if vim.fn.filereadable(parser_c) == 0 then return nil end
+
+    local bin_dir = _plugin_root .. "/bin"
+    vim.fn.mkdir(bin_dir, "p")
+
+    local is_win = vim.fn.has("win32") == 1
+    local lib_ext = is_win and ".dll" or ".so"
+    local so = bin_dir .. "/rapydscript" .. lib_ext
+
+    local so_mtime = vim.fn.getftime(so)
+    local needs = so_mtime < 0
+        or vim.fn.getftime(parser_c) > so_mtime
+        or vim.fn.getftime(scanner_c) > so_mtime
+
+    if needs then
+        local cmd
+        if is_win then
+            local compiler
+            if vim.fn.exepath("cl") ~= "" then
+                compiler = "cl"
+            elseif vim.fn.exepath("clang-cl") ~= "" then
+                compiler = "clang-cl"
+            else
+                vim.notify(
+                    "rapydscript: tree-sitter syntax highlighting requires cl or clang-cl on PATH",
+                    vim.log.levels.ERROR
+                )
+                return nil
+            end
+            -- /LD = build DLL, /nologo = suppress banner, /O2 = optimize,
+            -- /I = include path, /Fe: = output DLL path
+            cmd = string.format(
+                '"%s" /LD /nologo /O2 /I"%s" /Fe:"%s" "%s" "%s"',
+                compiler, ts_src, so, parser_c, scanner_c
+            )
+        else
+            local uname = vim.fn.system("uname -s"):gsub("%s+", "")
+            local shared = uname == "Darwin" and "-dynamiclib" or "-shared"
+            cmd = table.concat({
+                "cc", shared, "-fPIC", "-Os",
+                "-I", vim.fn.shellescape(ts_src),
+                "-o", vim.fn.shellescape(so),
+                vim.fn.shellescape(parser_c),
+                vim.fn.shellescape(scanner_c),
+            }, " ")
+        end
+
+        vim.notify("rapydscript: compiling tree-sitter parser…", vim.log.levels.INFO)
+        local out = vim.fn.system(cmd)
+        if vim.v.shell_error ~= 0 then
+            vim.notify("rapydscript: tree-sitter compile failed:\n" .. out, vim.log.levels.ERROR)
+            return nil
+        end
+    end
+
+    return so
+end)()
+
+local function _start_treesitter(bufnr)
+    if not _ts_so then return end
+
+    -- Add tree-sitter dir to rtp so nvim resolves queries/rapydscript/*.scm.
+    local ts_root = _repo_root .. "/tree-sitter"
+    local rtp = vim.opt.rtp:get()
+    if not vim.tbl_contains(rtp, ts_root) then
+        vim.opt.rtp:append(ts_root)
+    end
+
+    local ok, err = pcall(vim.treesitter.language.add, "rapydscript", { path = _ts_so })
+    if not ok then
+        vim.notify("rapydscript: failed to load tree-sitter parser: " .. tostring(err), vim.log.levels.ERROR)
+        return
+    end
+
+    local ts_ok, ts_err = pcall(vim.treesitter.start, bufnr, "rapydscript")
+    if not ts_ok then
+        vim.notify("rapydscript: tree-sitter start failed: " .. tostring(ts_err), vim.log.levels.ERROR)
+    end
+end
+
+local _min_system_version = { 0, 8, 0 }
+
+local function _parse_version(str)
+    local a, b, c = str:match("(%d+)%.(%d+)%.(%d+)")
+    if not a then return nil end
+    return { tonumber(a), tonumber(b), tonumber(c) }
+end
+
+local function _version_str(v)
+    return v and table.concat(v, ".") or "unknown"
+end
+
+local function _version_gte(v, min)
+    for i = 1, 3 do
+        if v[i] > min[i] then return true end
+        if v[i] < min[i] then return false end
+    end
+    return true
+end
+
+local function _query_version(bin)
+    local out = vim.fn.system({ bin, "--version" })
+    if vim.v.shell_error ~= 0 then return nil end
+    return _parse_version(out)
+end
+
+-- Prefer rapydscript on PATH; fall back to the copy in the repo checkout.
+-- Populates M._binary_info as a side-effect.
+local function _default_lsp_cmd()
+    local sys_path = vim.fn.exepath("rapydscript")
+    if sys_path ~= "" then
+        local ver = _query_version(sys_path)
+        local rejected = ver ~= nil and not _version_gte(ver, _min_system_version)
+        M._binary_info.system = { path = sys_path, version = ver, rejected = rejected }
+        if rejected then
+            vim.notify(
+                string.format(
+                    "rapydscript: system binary v%s is too old (minimum 0.8.0); using repo binary instead",
+                    _version_str(ver)
+                ),
+                vim.log.levels.WARN
+            )
+        else
+            return { "rapydscript", "lsp" }
+        end
+    end
+
+    local repo_bin = _repo_root .. "/bin/rapydscript"
+    if vim.fn.filereadable(repo_bin) == 1 then
+        local ver = _query_version(repo_bin)
+        M._binary_info.repo = { path = repo_bin, version = ver }
+        if vim.fn.has("win32") == 1 then
+            -- On Windows the shebang is not honoured; invoke via node explicitly.
+            return { "node", repo_bin, "lsp" }
+        end
+        return { repo_bin, "lsp" }
+    end
+
+    return { "rapydscript", "lsp" }
+end
+
+-- Expose tree-sitter compilation result for checkhealth.
+M._ts_so = _ts_so
+
+-- Populated by _default_lsp_cmd() below; read by lua/rapydscript/health.lua.
+M._binary_info = { system = nil, repo = nil }
+
+-- Expand glob patterns relative to root, keep only dirs that contain .pyj files,
+-- and return them colon-separated.  Returns nil when nothing matches.
+local function _resolve_import_paths(root, patterns)
+    local seen = {}
+    local dirs = {}
+    for _, pat in ipairs(patterns) do
+        local matches = vim.fn.glob(root .. "/" .. pat, false, true)
+        for _, path in ipairs(matches) do
+            local norm = vim.fn.fnamemodify(path, ":p"):gsub("/$", "")
+            if not seen[norm] and vim.fn.isdirectory(norm) == 1 then
+                if #vim.fn.glob(norm .. "/*.pyj", false, true) > 0 then
+                    seen[norm] = true
+                    dirs[#dirs + 1] = norm
+                end
+            end
+        end
+    end
+    return #dirs > 0 and table.concat(dirs, ":") or nil
+end
+
+M.defaults = {
+    cmd = _default_lsp_cmd(),
+    -- Glob patterns relative to the project root; matching dirs that contain
+    -- .pyj files are passed automatically as --import-path to the LSP server.
+    import_path_patterns = { ".", "src", "src/pyj" },
+    line_length = nil,
+    preferred_quote = nil,
+    filetypes = { "rapydscript" },
+    root_markers = { ".git", "package.json", "rapydscript.json" },
+}
+
+-- Current runtime settings, kept in sync whenever update_settings() is called.
+M._settings = {}
+
+local function build_cmd(opts, import_path)
+    local cmd = vim.deepcopy(opts.cmd)
+    if import_path then
+        vim.list_extend(cmd, { "--import-path", import_path })
+    end
+    if opts.line_length then
+        vim.list_extend(cmd, { "--line-length", tostring(opts.line_length) })
+    end
+    if opts.preferred_quote then
+        vim.list_extend(cmd, { "--preferred-quote", opts.preferred_quote })
+    end
+    return cmd
+end
+
+local function make_capabilities()
+    local caps = vim.lsp.protocol.make_client_capabilities()
+    -- Tell the server we support dynamic registration for workspace/didChangeConfiguration
+    -- so it will register that notification and accept live setting updates.
+    caps.workspace = caps.workspace or {}
+    caps.workspace.didChangeConfiguration = { dynamicRegistration = true }
+    return caps
+end
+
+-- Send workspace/didChangeConfiguration to every active rapydscript client.
+-- `new_settings` is a table with any subset of:
+--   line_length     (number)
+--   preferred_quote (string)  -- "single" | "double"
+function M.update_settings(new_settings)
+    new_settings = new_settings or {}
+
+    -- Merge into the module-level settings table.
+    if new_settings.line_length ~= nil then
+        M._settings.lineLength = new_settings.line_length
+    end
+    if new_settings.preferred_quote ~= nil then
+        M._settings.preferredQuote = new_settings.preferred_quote
+    end
+
+    local clients = vim.lsp.get_clients({ name = "rapydscript" })
+    if #clients == 0 then
+        vim.notify("rapydscript: no active LSP client found", vim.log.levels.WARN)
+        return
+    end
+    for _, client in ipairs(clients) do
+        client.notify("workspace/didChangeConfiguration", {
+            settings = { rapydscript = M._settings },
+        })
+    end
+end
+
+function M.setup(opts)
+    opts = vim.tbl_deep_extend("force", M.defaults, opts or {})
+    M._active_opts = opts
+
+    -- Seed the runtime settings table from the initial opts so that partial
+    -- update_settings() calls later always send the full current state.
+    M._settings = {
+        lineLength    = opts.line_length,
+        preferredQuote = opts.preferred_quote,
+    }
+
+    vim.api.nvim_create_autocmd("FileType", {
+        pattern = opts.filetypes,
+        callback = function(ev)
+            _start_treesitter(ev.buf)
+            local root = vim.fs.root(ev.buf, opts.root_markers)
+            local import_path = root
+                and _resolve_import_paths(root, opts.import_path_patterns)
+                or nil
+            vim.lsp.start({
+                name = "rapydscript",
+                cmd = build_cmd(opts, import_path),
+                root_dir = root or vim.fn.getcwd(),
+                capabilities = make_capabilities(),
+                settings = {
+                    rapydscript = M._settings,
+                },
+            })
+        end,
+    })
+end
+
+return M

package/local-agent.md

@@ -0,0 +1,28 @@
+initialize_command: bin/rapydscript self --complete
+copy_resource: node_modules
+copy_resource: dev
+prepend_to_path: bin
+
+# System Instructions & Project Context
+
+## Rules for Code Generation
+- **Error Handling**: Implement explicit error handling. Avoid silent failures or empty catch blocks.
+- **Dependency Minimization**: Use existing project utilities and native standard libraries before suggesting new external packages.
+- **Local Context**: Search the codebase for existing patterns before writing boilerplate structure from scratch.
+
+## Project Execution Workflows
+
+You both build and run the test suite by simply executing:
+
+./build
+
+The newly built tools are placed in the bin directory. 
+
+The test suite runs very fast so dont bother trying to run specific tests, just
+run the entire suite.
+
+## Verification Pipeline
+
+Before declaring a task complete, you must follow this exact verification lifecycle:
+1. Run the local **Build and Test Command** to guarantee zero compilation or compilation-stage errors and no test failures
+2. If errors occur, analyze the stdout logs completely before writing a fix. Do not guess.

package/package.json

@@ -8,16 +8,16 @@
     "language",
     "compiler"
   ],
-  "main": "tools/compiler.js",
+  "main": "tools/compiler.mjs",
   "scripts": {
     "test": "node bin/rapydscript self --complete --test",
     "start": "node bin/rapydscript",
     "build-self": "node bin/rapydscript self --complete"
   },
-  "version": "0.7.23",
+  "version": "0.8.0",
   "license": "BSD-2-Clause",
   "engines": {
-    "node": ">=0.12.0"
+    "node": ">=0.14.0"
   },
   "maintainers": [
     {
@@ -30,8 +30,7 @@
     "url": "https://github.com/kovidgoyal/rapydscript-ng.git"
   },
   "dependencies": {
-    "regenerator": ">= 0.12.1",
-    "uglify-js": ">= 3.0.15"
+    "terser": ">=5.49.0"
   },
   "optionalDependencies": {
     "v8-profiler": ">= 5.2.9"