rapydscript-ng 0.8.0 → 0.8.1

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+version 0.8.1
+=======================
+
+  * Fix concatenation of mixed string and f-string literal
+  * fmt and lsp now by default read format related settings from pyproject.toml, overridden via command line
+  * fmt command reports unfixable long lines in normal mode as well
+  * Fix newlines inside tuples not being allowed
+  * Miscellaneous improvements for the code auto formatter
+
 version 0.8.0
 =======================
 

package/README.md

@@ -104,6 +104,14 @@ Installation
 
 [Try RapydScript-ng live via an in-browser REPL!](https://sw.kovidgoyal.net/rapydscript/repl/)
 
+If you just want the standalone rapydscript binary, you can install it from
+PyPI, with::
+
+    pip install rapydscript-ng
+
+If you want the full package, needed to use the ``web-repl-export`` command, or
+integrate with a node project, you can instead install using npm.
+
 First make sure you have installed the latest version of [node.js](https://nodejs.org/) (You may need to restart your computer after this step). 
 
 From NPM for use as a command line app:

package/bin/build.ts

@@ -0,0 +1,117 @@
+#!/usr/bin/env bun
+// vim:ft=typescript:ts=4:et
+/*
+ * Generates bin/rapydscript.mjs — the bun compilation entry point — by scanning
+ * the filesystem for embeddable assets and prepending their import declarations
+ * and the __rapydscript_embedded__ global setup to the contents of bin/rapydscript.
+ *
+ * Usage:
+ *   bun bin/build.ts                         # generate bin/rapydscript.mjs only
+ *   bun bin/build.ts --compile --outfile foo  # generate + run: bun build bin/rapydscript.mjs --compile --outfile foo
+ */
+
+import path from 'path';
+import fs from 'fs';
+
+const repo_root = path.dirname(path.dirname(Bun.main));
+const dev_dir = path.join(repo_root, 'dev');
+const src_lib_dir = path.join(repo_root, 'src', 'lib');
+const bin_dir = path.join(repo_root, 'bin');
+const out_path = path.join(bin_dir, 'rapydscript.mjs');
+
+async function exists(p: string): Promise<boolean> {
+    try { await fs.promises.access(p); return true; } catch { return false; }
+}
+
+// --- Scan assets ---
+
+const DEV_TEXT_ASSETS = ['compiler.js', 'baselib-plain-pretty.js', 'baselib-plain-ugly.js'];
+const DEV_JSON_ASSETS = ['stdlib_modules.json'];
+
+const found_dev_text: string[] = [];
+for (const a of DEV_TEXT_ASSETS) {
+    if (await exists(path.join(dev_dir, a))) found_dev_text.push(a);
+}
+
+const found_dev_json: string[] = [];
+for (const a of DEV_JSON_ASSETS) {
+    if (await exists(path.join(dev_dir, a))) found_dev_json.push(a);
+}
+
+const stdlib_files: string[] = (await fs.promises.readdir(src_lib_dir))
+    .filter(f => f.endsWith('.pyj'))
+    .sort();
+
+// --- Build the generated asset section ---
+
+function var_name(prefix: string, filename: string): string {
+    return prefix + filename.replace(/[^a-zA-Z0-9]/g, '_');
+}
+
+const lines: string[] = [];
+
+lines.push('// Generated by bin/build.ts — do not edit manually');
+lines.push('// vim:ft=javascript:ts=4:et');
+lines.push('');
+lines.push('// === Embedded assets (generated by bin/build.ts) ===');
+
+for (const a of found_dev_text) {
+    lines.push(`import ${var_name('_dev_', a)} from '../dev/${a}' with { type: 'text' };`);
+}
+for (const a of found_dev_json) {
+    lines.push(`import ${var_name('_dev_', a)} from '../dev/${a}' with { type: 'json' };`);
+}
+for (const f of stdlib_files) {
+    lines.push(`import ${var_name('_stdlib_', f)} from '../src/lib/${f}' with { type: 'text' };`);
+}
+
+lines.push('');
+lines.push('globalThis.__rapydscript_embedded__ = {');
+
+for (const a of found_dev_text) {
+    lines.push(`    '${a}': ${var_name('_dev_', a)},`);
+}
+for (const a of found_dev_json) {
+    // strip extension for the key so consumers use e.g. embedded.stdlib_modules
+    const key = a.replace(/\.json$/, '').replace(/-/g, '_');
+    lines.push(`    ${key}: ${var_name('_dev_', a)},`);
+}
+lines.push('    stdlib: {');
+for (const f of stdlib_files) {
+    lines.push(`        '${f}': ${var_name('_stdlib_', f)},`);
+}
+lines.push('    },');
+lines.push('};');
+lines.push('');
+lines.push('// === Entry point (from bin/rapydscript) ===');
+lines.push('');
+
+// --- Append bin/rapydscript content (strip the shebang line) ---
+
+const entry_src = await fs.promises.readFile(path.join(bin_dir, 'rapydscript'), 'utf-8');
+const entry_lines = entry_src.split('\n');
+// Drop the first line if it's the shebang, and the vim modeline comment right after
+let start = 0;
+if (entry_lines[0].startsWith('#!')) start = 1;
+if (start < entry_lines.length && entry_lines[start].trim().startsWith('// vim:')) start++;
+
+lines.push(...entry_lines.slice(start));
+
+// Ensure the file ends with a newline
+const content = lines.join('\n');
+const final_content = content.endsWith('\n') ? content : content + '\n';
+
+await fs.promises.writeFile(out_path, final_content, 'utf-8');
+console.log(`Written ${path.relative(repo_root, out_path)}`);
+console.log(`  ${found_dev_text.length} dev text assets, ${found_dev_json.length} dev json assets, ${stdlib_files.length} stdlib files`);
+
+// --- Optionally run bun build with passed-through args ---
+
+const extra_args = process.argv.slice(2);
+if (extra_args.length > 0) {
+    const cmd_args = ['build', out_path, ...extra_args];
+    console.log(`Running: bun ${cmd_args.join(' ')}`);
+    const proc = Bun.spawn(['bun', ...cmd_args], { stdout: 'inherit', stderr: 'inherit', stdin: 'inherit' });
+    const code = await proc.exited;
+    process.exit(code);
+}

package/build_wheels.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+# vim:fileencoding=utf-8
+
+import os
+import sys
+import json
+import shutil
+import tempfile
+import subprocess
+import re
+
+BASE = os.path.dirname(os.path.abspath(__file__))
+
+# Maps (bun_target, wheel_platform_tag, binary_name)
+PLATFORMS = [
+    ("bun-linux-x64", "manylinux_2_17_x86_64", "rapydscript"),
+    ("bun-linux-arm64", "manylinux_2_17_aarch64", "rapydscript"),
+    ("bun-linux-x64-musl", "musllinux_1_2_x86_64", "rapydscript"),
+    ("bun-linux-arm64-musl", "musllinux_1_2_aarch64", "rapydscript"),
+    ("bun-darwin-x64", "macosx_10_9_x86_64", "rapydscript"),
+    ("bun-darwin-arm64", "macosx_11_0_arm64", "rapydscript"),
+    ("bun-windows-x64", "win_amd64", "rapydscript.exe"),
+]
+
+
+def normalize_name(name):
+    return re.sub(r"[-_.]+", "_", name).lower()
+
+
+def load_metadata():
+    with open(os.path.join(BASE, "package.json"), "rb") as f:
+        return json.load(f)
+
+
+def build_binary(bun_target, outfile):
+    cmd = [
+        "bun",
+        "bin/build.ts",
+        "--compile",
+        f"--outfile={outfile}",
+        f"--target={bun_target}",
+    ]
+    print(f"  Building {bun_target} ...")
+    subprocess.check_call(cmd, cwd=BASE)
+
+
+def write_wheel_metadata(dist_info_dir, meta, wheel_platform):
+    maintainers = meta.get("maintainers", [])
+    author = maintainers[0].get("name", "") if maintainers else ""
+    author_email = maintainers[0].get("email", "") if maintainers else ""
+    repo_url = meta.get("repository", {}).get("url", "")
+
+    with open(os.path.join(dist_info_dir, "WHEEL"), "w") as f:
+        f.write("Wheel-Version: 1.0\n")
+        f.write("Generator: wheel.py\n")
+        f.write("Root-Is-Purelib: false\n")
+        f.write(f"Tag: py3-none-{wheel_platform}\n")
+
+    with open(os.path.join(dist_info_dir, "METADATA"), "w") as f:
+        f.write("Metadata-Version: 2.1\n")
+        f.write(f"Name: {meta['name']}\n")
+        f.write(f"Version: {meta['version']}\n")
+        f.write(f"Summary: {meta.get('description', '')}\n")
+        if meta.get("homepage"):
+            f.write(f"Home-page: {meta['homepage']}\n")
+        if author:
+            f.write(f"Author: {author}\n")
+        if author_email:
+            f.write(f"Author-email: {author_email}\n")
+        if meta.get("license"):
+            f.write(f"License: {meta['license']}\n")
+        if meta.get("keywords"):
+            f.write(f"Keywords: {', '.join(meta['keywords'])}\n")
+        if repo_url:
+            f.write(f"Project-URL: Source Code, {repo_url}\n")
+        f.write("Description-Content-Type: text/markdown")
+        print(file=f)
+        with open("README.md") as s:
+            f.write(s.read())
+
+
+def build_wheel(meta, bun_target, wheel_platform, binary_name, dest_dir, tmpdir):
+    norm_name = normalize_name(meta["name"])
+    version = meta["version"]
+
+    suffix = ".exe" if binary_name.endswith(".exe") else ""
+    binary_outfile = os.path.join(tmpdir, f"rapydscript-{bun_target}{suffix}")
+    build_binary(bun_target, binary_outfile)
+
+    # Assemble unpacked wheel layout
+    wheel_dir = os.path.join(tmpdir, f"{norm_name}-{version}-{wheel_platform}")
+    dist_info_dir = os.path.join(wheel_dir, f"{norm_name}-{version}.dist-info")
+    scripts_dir = os.path.join(wheel_dir, f"{norm_name}-{version}.data", "scripts")
+    os.makedirs(dist_info_dir)
+    os.makedirs(scripts_dir)
+
+    dest_binary = os.path.join(scripts_dir, binary_name)
+    shutil.copy2(binary_outfile, dest_binary)
+    os.chmod(dest_binary, 0o755)
+
+    write_wheel_metadata(dist_info_dir, meta, wheel_platform)
+
+    print("  Packing wheel ...")
+    subprocess.check_call(
+        [sys.executable, "-m", "wheel", "pack", wheel_dir, "--dest-dir", dest_dir],
+        cwd=tmpdir,
+    )
+
+    return f"{norm_name}-{version}-py3-none-{wheel_platform}.whl"
+
+
+def main():
+    meta = load_metadata()
+    dest_dir = os.path.join(BASE, "dist")
+    os.makedirs(dest_dir, exist_ok=True)
+    for x in os.listdir(dest_dir):
+        os.remove(os.path.join(dest_dir, x))
+
+    wheels = []
+    with tempfile.TemporaryDirectory(prefix="rapydscript-wheel-") as tmpdir:
+        for bun_target, wheel_platform, binary_name in PLATFORMS:
+            print(f"\n[{bun_target}]")
+            whl = build_wheel(
+                meta, bun_target, wheel_platform, binary_name, dest_dir, tmpdir
+            )
+            wheels.append(whl)
+            print(f"  -> dist/{whl}")
+
+    print(f"\nBuilt {len(wheels)} wheels in dist/")
+
+
+if __name__ == "__main__":
+    main()

package/editor-plugins/README.md

@@ -0,0 +1,80 @@
+# Plugins to integrate with editors
+
+Wires up the RapydScript LSP server (`rapydscript lsp`) as a
+LSP client for various editors (currently only Neovim).
+It also enables treesitter based syntax highlighting.
+
+## Features
+
+Provided by the LSP server — no extra plugins required:
+
+- **Completions** — in-scope symbols, builtins, keywords, and member completion (`mod.<TAB>`)
+- **Diagnostics** — lint checks and unresolved import warnings, updated as you type
+- **Hover** (`K`) — kind, origin, and docstring of the symbol under the cursor
+- **Go to definition** (`gd`) — including jumping into imported modules
+- **Find references** (`gr`) — resolved across files through the import graph
+- **Rename** (`<leader>rn`) — renames everywhere across the workspace
+- **Code actions** (`<leader>ca`) — remove unused import/local, add `# noqa`, format document
+- **Document formatting** (`<leader>f`) — same as `rapydscript fmt`
+- **Document symbols** — outline view via any symbols picker
+
+## Requirements
+
+- `node` (from nodejs) on your `$PATH` 
+
+- **Syntax highlighting only**: a C compiler on your `$PATH` is required to compile the
+  tree-sitter parser the first time the plugin loads.  On Linux/macOS any `cc`-compatible
+  compiler works (gcc, clang, etc.).  On Windows, `cl` (MSVC) or `clang-cl` must be
+  available. LSP features work regardless of whether compilation
+  succeeds.
+
+## Neovim Installation
+
+Needs Neovim >= 0.12. Just add the following to your ``~/.config/nvim/init.lua``, changing the
+options to suit yourself:
+
+```lua
+vim.pack.add({ { src = "https://github.com/kovidgoyal/rapydscript-ng", name = "rapydscript" } }, {
+    load = function(plug_data)
+        vim.cmd.packadd(plug_data.spec.name)
+        for _, pack in ipairs(vim.pack.get({ plug_data.spec.name })) do
+            vim.opt.rtp:append(pack.path .. "/editor-plugins/nvim/rapydscript")
+            dofile(pack.path .. '/editor-plugins/nvim.lua').setup({
+                -- options you should customize
+                line_length = 80,
+                preferred_quote = "single",
+            })
+        end
+    end
+})
+```
+
+Or if you want to load it manually for older versions of Neovim:
+
+```lua
+dofile("/path/to/rapydscript/editor-plugins/nvim.lua").setup()
+```
+
+## Configuration reference
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `cmd` | `string[]` | `{"rapydscript","lsp"}` | Command used to start the server |
+| `import_path_patterns` | `string[]` | `{".", "src", "src/pyj"}` | Glob patterns relative to the project root; matching directories that contain `.pyj` files are passed automatically as `--import-path` |
+| `line_length` | `number\|nil` | `nil` | Max line length for the formatter, passed as `--line-length` |
+| `preferred_quote` | `string\|nil` | `nil` | `"single"` or `"double"`, passed as `--preferred-quote` |
+| `join_lines` | `boolean\|nil` | `nil` | When `true`, multi-line statements that fit within `line_length` are joined onto one line, passed as `--join-lines`. Disabled by default. |
+| `filetypes` | `string[]` | `{"rapydscript"}` | Filetypes that trigger server attachment |
+| `root_markers` | `string[]` | `{".git","package.json","rapydscript.json"}` | Files/dirs used to detect the project root |
+
+### Automatic import path detection
+
+When a project root is found (via `root_markers`), the plugin expands each pattern in
+`import_path_patterns` as a glob relative to that root.  Any matching directory that
+contains at least one `.pyj` file is added to the server's import search path
+automatically — no manual configuration needed for standard project layouts.
+
+If no project root is detected the setting has no effect.
+
+To add custom search locations alongside the defaults, use
+``import_path_patterns``.

package/editor-plugins/nvim.lua

@@ -0,0 +1,321 @@
+#!/usr/bin/env lua
+--
+-- nvim.lua
+-- Copyright (C) 2026 Kovid Goyal <kovid at kovidgoyal.net>
+--
+-- Distributed under terms of the MIT license.
+--
+
+local M = {}
+
+local _plugin_root = vim.fn.fnamemodify(
+    debug.getinfo(1, "S").source:sub(2), ":p:h"
+)
+local _repo_root = vim.fn.fnamemodify(_plugin_root, ":h")
+local ts_root = _repo_root .. '/tree-sitter'
+
+-- _ts_so holds the .so/.dll path once the background build succeeds, nil otherwise.
+local _ts_so = nil
+
+-- Tracks the async build lifecycle.
+local _build_state = {
+    started = false, -- set when _build_async() is called
+    done    = false, -- set when the job exits (success or failure)
+    waiters = {},    -- callbacks queued while the job is running
+    error   = nil,   -- stderr from a failed build, or a plain error string
+}
+
+-- Mark the build finished, optionally record the .so path, and fire any waiters.
+local function _build_finish(success, so, err)
+    if success then _ts_so = so end
+    _build_state.done    = true
+    _build_state.error   = err or nil
+    local ws             = _build_state.waiters
+    _build_state.waiters = {}
+    for _, cb in ipairs(ws) do
+        vim.schedule(cb)
+    end
+end
+
+-- Run cb immediately if the build is already done; otherwise enqueue it.
+local function _when_built(cb)
+    if _build_state.done then
+        cb()
+    else
+        table.insert(_build_state.waiters, cb)
+    end
+end
+
+-- Register the compiled shared library with neovim's tree-sitter runtime.
+-- Returns true on success.
+local function _register_queries()
+    local queries_dir = ts_root .. '/queries/'
+    vim.treesitter.query.set(
+        'rapydscript', 'highlights', table.concat(vim.fn.readfile(queries_dir .. 'highlights.scm'), "\n"))
+    vim.treesitter.query.set(
+        'rapydscript', 'indents', table.concat(vim.fn.readfile(queries_dir .. 'indents.scm'), "\n"))
+    vim.treesitter.query.set(
+        'rapydscript', 'injections', table.concat(vim.fn.readfile(queries_dir .. 'injections.scm'), "\n"))
+    vim.treesitter.query.set(
+        'rapydscript', 'locals', table.concat(vim.fn.readfile(queries_dir .. 'locals.scm'), "\n"))
+end
+
+
+local function _load_parser(so)
+    vim.treesitter.language.register("rapydscript", "rapydscript")
+    local ok, err = pcall(vim.treesitter.language.add, "rapydscript", { path = so })
+    if not ok then
+        vim.notify("rapydscript: failed to load tree-sitter parser: " .. tostring(err), vim.log.levels.ERROR)
+        return false
+    end
+    _register_queries()
+    return true
+end
+
+-- Compile the tree-sitter parser in a background job.
+local function _build_async()
+    _build_state.started = true
+
+    local ts_src = ts_root .. "/src"
+    local parser_c = ts_src .. "/parser.c"
+    local scanner_c = ts_src .. "/scanner.c"
+    if vim.fn.filereadable(parser_c) == 0 then
+        local msg = "parser.c not found: " .. parser_c
+        vim.notify("rapydscript: " .. msg, vim.log.levels.ERROR)
+        _build_finish(false, nil, msg)
+        return
+    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 not needs then
+        -- Already up-to-date; load the existing .so and mark done without spawning a job.
+        _build_finish(_load_parser(so), so)
+        return
+    end
+
+    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
+            local msg = "tree-sitter syntax highlighting requires cl or clang-cl on PATH"
+            vim.notify("rapydscript: " .. msg, vim.log.levels.ERROR)
+            _build_finish(false, nil, msg)
+            return
+        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 shared = vim.loop.os_uname().sysname == "Darwin" and "-dynamiclib" or "-shared"
+        cmd = { "cc", shared, "-fPIC", "-Os", "-I", ts_src, "-o", so, parser_c, scanner_c }
+    end
+
+    vim.notify("rapydscript: compiling tree-sitter parser…", vim.log.levels.INFO)
+
+    local stderr_lines = {}
+    vim.fn.jobstart(cmd, {
+        on_stdout = function(_, _data) end,
+        on_stderr = function(_, data)
+            if data then vim.list_extend(stderr_lines, data) end
+        end,
+        on_exit = function(_, code)
+            vim.schedule(function()
+                if code ~= 0 then
+                    local stderr = table.concat(stderr_lines, "\n")
+                    vim.notify(
+                        "rapydscript: tree-sitter compile failed:\n" .. stderr,
+                        vim.log.levels.ERROR
+                    )
+                    _build_finish(false, nil, stderr)
+                    return
+                end
+                _build_finish(_load_parser(so), so, nil)
+            end)
+        end,
+    })
+end
+
+local function _start_treesitter(bufnr)
+    _when_built(function()
+        if not _ts_so then 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)
+end
+
+-- Populates M._binary_info as a side-effect.
+local function _default_lsp_cmd()
+    local repo_bin = _repo_root .. "/bin/rapydscript"
+    M._binary_info.repo = { path = repo_bin }
+    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
+
+-- Expose tree-sitter compilation result for checkhealth.
+-- Blocks up to 30 s if the background build is still running.
+M._tree_sitter_path = function()
+    if _build_state.started and not _build_state.done then
+        vim.wait(30000, function() return _build_state.done end, 50)
+    end
+    return _ts_so
+end
+
+-- Expose the build error (if any) for checkhealth.
+-- Must be called after _tree_sitter_path() so the build is already settled.
+M._tree_sitter_error = function()
+    return _build_state.error
+end
+
+-- 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
+    if opts.join_lines then
+        vim.list_extend(cmd, { "--join-lines" })
+    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
+    if new_settings.join_lines ~= nil then
+        M._settings.joinLines = new_settings.join_lines
+    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)
+    vim.filetype.add({ extension = { pyj = 'rapydscript' } })
+    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,
+        joinLines      = opts.join_lines,
+    }
+    _build_async()
+
+    vim.api.nvim_create_autocmd("FileType", {
+        pattern = opts.filetypes,
+        callback = function(ev)
+            vim.bo[ev.buf].syntax = "off" -- use treesitter for syntax highlighting
+            _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/package.json

@@ -14,7 +14,7 @@
     "start": "node bin/rapydscript",
     "build-self": "node bin/rapydscript self --complete"
   },
-  "version": "0.8.0",
+  "version": "0.8.1",
   "license": "BSD-2-Clause",
   "engines": {
     "node": ">=0.14.0"