@gjsify/cli 0.4.28 → 0.4.30

package/lib/utils/oxc-resolve.js

@@ -0,0 +1,264 @@
+// oxc (oxlint + oxfmt) resolution + spawn helpers.
+//
+// Replaces the former `biome-resolve.ts`. oxc ships its tools differently
+// from Biome:
+//
+//   - The user-facing npm packages `oxlint` and `oxfmt` are thin Node ESM
+//     launchers (`bin/oxlint` → `dist/cli.js`, `bin/oxfmt` → `dist/cli.js`).
+//   - The actual native code lives in per-platform NAPI binding packages
+//     (`@oxlint/binding-<target>`, `@oxfmt/binding-<target>`, e.g.
+//     `@oxlint/binding-linux-x64-gnu`), declared as optionalDependencies of
+//     the launcher package and loaded via napi-rs's `requireNative()`.
+//
+// Unlike Biome — whose per-platform package was a single self-contained Rust
+// binary we could spawn directly, skipping its Node launcher — oxlint's JS
+// plugin API (used by the internal `oxlint-plugin-gjsify` rule) lives in the
+// JS launcher (`dist/cli.js`). The plugin host loads `.ts`/`.js` plugin files
+// at runtime, so a configured plugin REQUIRES spawning oxlint through its Node
+// launcher rather than calling a bare binary. We therefore resolve and spawn
+// the package launcher with `node` for both tools — uniform and correct for
+// the plugin case.
+//
+// Resolution order (workspace-aware) for each launcher:
+//   1. Project's local node_modules (cwd)
+//   2. Workspace root's node_modules (walk up via findWorkspaceRoot)
+//   3. Parent dirs as a last resort
+//   4. ENOENT → install hint
+//
+// We still reuse Biome's platform/arch/musl detection — it's used to name the
+// expected NAPI binding package in the not-found install hint, so the user
+// knows exactly which optionalDependency npm failed to place.
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+import { findWorkspaceRoot } from './workspace-root.js';
+/**
+ * Map Node.js `process.platform` + `arch` (+ musl on Linux) to the
+ * napi-rs binding-package suffix oxc uses, e.g. `linux-x64-gnu`,
+ * `linux-x64-musl`, `darwin-arm64`, `win32-x64-msvc`.
+ *
+ * Mirrors biome-resolve's platform detection (same musl probe), adapted to
+ * oxc's napi-rs target naming (gnu/musl libc suffix on Linux, -msvc on
+ * Windows).
+ */
+function oxcBindingSuffix() {
+    const platform = process.platform;
+    const arch = process.arch;
+    let plat;
+    if (platform === 'linux')
+        plat = 'linux';
+    else if (platform === 'darwin')
+        plat = 'darwin';
+    else if (platform === 'win32')
+        plat = 'win32';
+    else
+        throw new Error(`[gjsify oxc] Unsupported platform: ${platform}`);
+    let a;
+    if (arch === 'x64')
+        a = 'x64';
+    else if (arch === 'arm64')
+        a = 'arm64';
+    else
+        throw new Error(`[gjsify oxc] Unsupported arch on ${plat}: ${arch}`);
+    if (plat === 'linux') {
+        // musl detection on Linux — oxc ships separate musl/gnu bindings.
+        // Same approach as biome's launcher: probe for the musl loader.
+        // glibc systems have `/lib/ld-linux-*`, musl has `/lib/ld-musl-*`.
+        let libc = 'gnu';
+        try {
+            const { readdirSync } = require('node:fs');
+            const libEntries = readdirSync('/lib');
+            if (libEntries.some((e) => e.startsWith('ld-musl-'))) {
+                libc = 'musl';
+            }
+        }
+        catch {
+            // /lib unreadable — fall through, glibc is the safer default
+        }
+        return `${plat}-${a}-${libc}`;
+    }
+    if (plat === 'win32')
+        return `${plat}-${a}-msvc`;
+    // darwin
+    return `${plat}-${a}`;
+}
+/** NAPI binding scope per tool: `@oxlint/binding-*` / `@oxfmt/binding-*`. */
+function bindingPackageName(tool) {
+    const scope = tool === 'oxlint' ? '@oxlint' : '@oxfmt';
+    return `${scope}/binding-${oxcBindingSuffix()}`;
+}
+/**
+ * Search a starting directory's `node_modules/<pkg>/<relPath>` and return the
+ * absolute path if it exists, else null.
+ */
+function probeNodeModules(dir, pkg, relPath) {
+    const candidate = join(dir, 'node_modules', pkg, relPath);
+    return existsSync(candidate) ? candidate : null;
+}
+/**
+ * Resolve the absolute path to a tool's Node ESM launcher
+ * (`node_modules/<tool>/bin/<tool>`). Walks cwd → workspace-root → parents.
+ *
+ * Throws {@link OxcNotFoundError} with a clear install hint when not found.
+ */
+export function findOxcLauncher(tool, cwd = process.cwd()) {
+    const relPath = join('bin', tool);
+    // 1. Local node_modules
+    const local = probeNodeModules(cwd, tool, relPath);
+    if (local)
+        return local;
+    // 2. Walk up to workspace root, probe its node_modules
+    const wsRoot = findWorkspaceRoot(cwd);
+    if (wsRoot && wsRoot !== cwd) {
+        const fromRoot = probeNodeModules(wsRoot, tool, relPath);
+        if (fromRoot)
+            return fromRoot;
+    }
+    // 3. Walk parent dirs as a last resort (nested-without-workspace setups)
+    let dir = resolve(cwd, '..');
+    for (let i = 0; i < 6; i++) {
+        const found = probeNodeModules(dir, tool, relPath);
+        if (found)
+            return found;
+        const parent = resolve(dir, '..');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new OxcNotFoundError(tool, cwd);
+}
+export class OxcNotFoundError extends Error {
+    tool;
+    cwd;
+    constructor(tool, cwd) {
+        const binding = (() => {
+            try {
+                return bindingPackageName(tool);
+            }
+            catch {
+                return `@${tool === 'oxlint' ? 'oxlint' : 'oxfmt'}/binding-<platform>`;
+            }
+        })();
+        super(`[gjsify oxc] ${tool} not found.\n` +
+            `  Expected: ${tool}/bin/${tool} in node_modules of ${cwd} or any workspace root above it.\n` +
+            `  Install it via: gjsify install -D ${tool}\n` +
+            `  (this adds ${tool} to devDependencies; the matching ${binding} ` +
+            `napi binding lands automatically as an optionalDependency.)`);
+        this.tool = tool;
+        this.cwd = cwd;
+        this.name = 'OxcNotFoundError';
+    }
+}
+/**
+ * Walk up from a starting directory to find the nearest oxlint config
+ * (`.oxlintrc.json`). Returns absolute path or null.
+ */
+export function findOxlintConfig(cwd = process.cwd()) {
+    return findConfigFile(cwd, ['.oxlintrc.json']);
+}
+/**
+ * Walk up from a starting directory to find the nearest oxfmt config
+ * (`.oxfmtrc` / `.oxfmtrc.json`). Returns absolute path or null.
+ */
+export function findOxfmtConfig(cwd = process.cwd()) {
+    return findConfigFile(cwd, ['.oxfmtrc', '.oxfmtrc.json']);
+}
+function findConfigFile(cwd, names) {
+    let dir = cwd;
+    for (let i = 0; i < 12; i++) {
+        for (const name of names) {
+            const path = join(dir, name);
+            if (existsSync(path))
+                return path;
+        }
+        const parent = resolve(dir, '..');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Spawn an oxc tool (oxlint / oxfmt) via its Node ESM launcher. Inherits
+ * stdio so the tool's own output (diagnostics, reformatted files, summary
+ * lines) reaches the user.
+ *
+ * The launcher is run with the current Node executable (`process.execPath`)
+ * so the JS plugin host is available — required for oxlint's `jsPlugins`.
+ *
+ * Returns the exit code; never throws on non-zero exit (callers check it).
+ */
+export function runOxc(tool, args, opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const launcher = findOxcLauncher(tool, cwd);
+    const node = process.execPath || 'node';
+    if (opts.verbose) {
+        console.log(`[gjsify oxc] ${node} ${launcher} ${args.join(' ')}`);
+    }
+    return new Promise((res, rej) => {
+        const spawnOpts = { stdio: 'inherit', cwd };
+        const child = spawn(node, [launcher, ...args], spawnOpts);
+        child.on('error', (err) => {
+            if (err.code === 'ENOENT') {
+                rej(new OxcNotFoundError(tool, cwd));
+            }
+            else {
+                rej(err);
+            }
+        });
+        child.on('exit', (code, signal) => {
+            if (signal) {
+                console.error(`[gjsify oxc] ${tool} terminated by signal ${signal}`);
+                res(1);
+                return;
+            }
+            res(code ?? 0);
+        });
+    });
+}
+/** Convenience wrappers. */
+export function runOxlint(args, opts = {}) {
+    return runOxc('oxlint', args, opts);
+}
+export function runOxfmt(args, opts = {}) {
+    return runOxc('oxfmt', args, opts);
+}
+/**
+ * Lazy-load the embedded `.oxlintrc.json` scaffold template. The
+ * static-read-inliner matches this `readFileSync(new URL(<lit>,
+ * import.meta.url), 'utf-8')` shape at build time and inlines the file into
+ * the GJS bundle, so the template is available without runtime file I/O
+ * against the install dir. (Same mechanism the old `loadBiomeTemplate()`
+ * relied on — the shape must stay exactly this for the inliner to fire.)
+ */
+export function loadOxlintTemplate() {
+    return readFileSync(new URL('../templates/oxlintrc.json.tmpl', import.meta.url), 'utf-8');
+}
+/** Lazy-load the embedded `.oxfmtrc` scaffold template (same inliner shape). */
+export function loadOxfmtTemplate() {
+    return readFileSync(new URL('../templates/oxfmtrc.tmpl', import.meta.url), 'utf-8');
+}
+/** Helper for callers to surface the install hint to the user cleanly. */
+export function printOxcNotFound(err) {
+    console.error(err.message);
+}
+/**
+ * Has the given oxc tool's npm package (or its companion) been declared in the
+ * project's dependencies? Useful as a cheap pre-flight check — `gjsify flatpak
+ * init`'s post-format hook uses this to decide whether to auto-format outputs.
+ *
+ * Checks for `oxfmt` by default (the formatter), since that is what the
+ * post-format hook would invoke.
+ */
+export function hasOxcDevDep(cwd = process.cwd(), tool = 'oxfmt') {
+    const pkgPath = join(cwd, 'package.json');
+    if (!existsSync(pkgPath))
+        return false;
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return Boolean(pkg?.devDependencies?.[tool] || pkg?.dependencies?.[tool]);
+    }
+    catch {
+        return false;
+    }
+}

package/lib/utils/pkg-json-edit.js

@@ -93,12 +93,7 @@ export function defaultRangeFromVersion(version) {
 }
 function sortKnownDepFields(pkg) {
     const out = { ...pkg };
-    for (const kind of [
-        'dependencies',
-        'devDependencies',
-        'peerDependencies',
-        'optionalDependencies',
-    ]) {
+    for (const kind of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
         const block = out[kind];
         if (!block)
             continue;

package/lib/utils/run-gjs.js

@@ -30,10 +30,7 @@ export function computeNativeEnvForBundle(bundlePath, cwd = process.cwd()) {
     const cwdPackages = detectNativePackages(cwd);
     const bundlePackages = detectNativePackages(dirname(resolvedBundle));
     const seen = new Set(cwdPackages.map((p) => p.name));
-    const nativePackages = [
-        ...cwdPackages,
-        ...bundlePackages.filter((p) => !seen.has(p.name)),
-    ];
+    const nativePackages = [...cwdPackages, ...bundlePackages.filter((p) => !seen.has(p.name))];
     const env = buildNativeEnv(nativePackages);
     const envPrefix = Object.entries(env)
         .filter(([, value]) => value !== undefined && value !== '')

package/lib/utils/run-lifecycle-script.js

@@ -42,9 +42,7 @@ export async function runLifecycleScript(wsDir, pkg, name, opts = {}) {
     // tools like biome / esbuild / tsc lose ANSI color in piped contexts
     // (CI logs, redirected output) because `process.stdout.isTTY` is
     // false for the spawned child.
-    const colorEnv = process.env.FORCE_COLOR !== undefined || process.env.NO_COLOR !== undefined
-        ? {}
-        : { FORCE_COLOR: '1' };
+    const colorEnv = process.env.FORCE_COLOR !== undefined || process.env.NO_COLOR !== undefined ? {} : { FORCE_COLOR: '1' };
     const env = {
         ...process.env,
         ...colorEnv,
@@ -52,7 +50,7 @@ export async function runLifecycleScript(wsDir, pkg, name, opts = {}) {
         npm_lifecycle_event: name,
         npm_package_name: pkg.name ?? '',
         npm_package_version: pkg.version ?? '',
-        ...(opts.env ?? {}),
+        ...opts.env,
     };
     // `'inherit-stderr'` is our extension on top of node's stdio modes —
     // child stdin inherits, child stdout → parent's stderr (fd 2), child
@@ -60,9 +58,7 @@ export async function runLifecycleScript(wsDir, pkg, name, opts = {}) {
     // prepack's log lines don't get interleaved with the JSON we emit on
     // parent stdout. `spawn`'s `stdio` accepts numeric fds in array form
     // and routes the child's matching stream to that fd.
-    const stdioConfig = opts.stdio === 'inherit-stderr'
-        ? ['inherit', 2, 2]
-        : (opts.stdio ?? 'inherit');
+    const stdioConfig = opts.stdio === 'inherit-stderr' ? ['inherit', 2, 2] : (opts.stdio ?? 'inherit');
     await new Promise((resolveOk, reject) => {
         const child = spawn(literal, [], {
             cwd: wsDir,

package/lib/utils/workspace-root.js

@@ -34,7 +34,9 @@ export function findWorkspaceRoot(start) {
                     if (dir === start || ws.some((w) => w.location === start))
                         return dir;
                 }
-                catch { /* not a usable workspace root */ }
+                catch {
+                    /* not a usable workspace root */
+                }
             }
         }
         const parent = resolve(dir, '..');

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/cli",
-    "version": "0.4.28",
+    "version": "0.4.30",
     "description": "CLI for Gjsify",
     "type": "module",
     "main": "lib/index.js",
@@ -55,7 +55,7 @@
                             "item": "`gjsify dlx <pkg>` — fetch and run any npm package's GJS bundle without persisting it"
                         },
                         {
-                            "item": "`gjsify lint` / `gjsify format` — Biome-powered linter + formatter"
+                            "item": "`gjsify lint` / `gjsify format` — oxc-powered linter (oxlint) + formatter (oxfmt)"
                         },
                         {
                             "item": "`gjsify flatpak {init,build,check,deps,ci}` — pack a GJS app or CLI into a Flatpak end-to-end"
@@ -106,7 +106,7 @@
         "clear": "rm -rf lib dist tsconfig.tsbuildinfo || exit 0",
         "check": "tsc --noEmit",
         "start": "node lib/index.js",
-        "build": "tsc && mkdir -p lib/templates/flatpak && cp -L src/templates/install.mjs.tmpl lib/templates/install.mjs.tmpl && cp src/templates/flatpak/*.tmpl lib/templates/flatpak/ && cp src/templates/biome.json.tmpl lib/templates/biome.json.tmpl && gjsify run chmod",
+        "build": "tsc && mkdir -p lib/templates/flatpak && cp -L src/templates/install.mjs.tmpl lib/templates/install.mjs.tmpl && cp src/templates/flatpak/*.tmpl lib/templates/flatpak/ && cp src/templates/oxlintrc.json.tmpl lib/templates/oxlintrc.json.tmpl && cp src/templates/oxfmtrc.tmpl lib/templates/oxfmtrc.tmpl && gjsify run chmod",
         "build:gjs-bundle": "node lib/index.js build src/index.ts --app gjs --outfile dist/cli.gjs.mjs --shebang",
         "chmod": "chmod +x ./lib/index.js",
         "build:test:node": "node lib/index.js build src/test.mts --app node --outfile dist/test.node.mjs",
@@ -120,18 +120,18 @@
         "cli"
     ],
     "dependencies": {
-        "@gjsify/buffer": "^0.4.28",
-        "@gjsify/create-app": "^0.4.28",
-        "@gjsify/node-globals": "^0.4.28",
-        "@gjsify/node-polyfills": "^0.4.28",
-        "@gjsify/npm-registry": "^0.4.28",
-        "@gjsify/resolve-npm": "^0.4.28",
-        "@gjsify/rolldown-plugin-gjsify": "^0.4.28",
-        "@gjsify/rolldown-plugin-pnp": "^0.4.28",
-        "@gjsify/semver": "^0.4.28",
-        "@gjsify/tar": "^0.4.28",
-        "@gjsify/web-polyfills": "^0.4.28",
-        "@gjsify/workspace": "^0.4.28",
+        "@gjsify/buffer": "^0.4.30",
+        "@gjsify/create-app": "^0.4.30",
+        "@gjsify/node-globals": "^0.4.30",
+        "@gjsify/node-polyfills": "^0.4.30",
+        "@gjsify/npm-registry": "^0.4.30",
+        "@gjsify/resolve-npm": "^0.4.30",
+        "@gjsify/rolldown-plugin-gjsify": "^0.4.30",
+        "@gjsify/rolldown-plugin-pnp": "^0.4.30",
+        "@gjsify/semver": "^0.4.30",
+        "@gjsify/tar": "^0.4.30",
+        "@gjsify/web-polyfills": "^0.4.30",
+        "@gjsify/workspace": "^0.4.30",
         "cosmiconfig": "^9.0.1",
         "get-tsconfig": "^4.14.0",
         "pkg-types": "^2.3.1",
@@ -139,12 +139,12 @@
         "yargs": "^18.0.0"
     },
     "devDependencies": {
-        "@gjsify/unit": "^0.4.28",
+        "@gjsify/unit": "^0.4.30",
         "@types/yargs": "^17.0.35",
         "typescript": "^6.0.3"
     },
     "peerDependencies": {
-        "@gjsify/rolldown-native": "^0.4.28"
+        "@gjsify/rolldown-native": "^0.4.30"
     },
     "peerDependenciesMeta": {
         "@gjsify/rolldown-native": {

package/lib/templates/biome.json.tmpl

@@ -1,79 +0,0 @@
-{
-    "$schema": "https://biomejs.dev/schemas/2.4.13/schema.json",
-    "formatter": {
-        "enabled": true,
-        "indentStyle": "space",
-        "indentWidth": 4,
-        "lineWidth": 120,
-        "lineEnding": "lf"
-    },
-    "linter": {
-        "enabled": true,
-        "rules": {
-            "recommended": true,
-            "style": {
-                "useImportType": "warn",
-                "useNodejsImportProtocol": "error",
-                "noNonNullAssertion": "off"
-            },
-            "suspicious": {
-                "noExplicitAny": "warn",
-                "noConsole": "off"
-            },
-            "correctness": {
-                "noUnusedImports": "warn"
-            }
-        }
-    },
-    "javascript": {
-        "formatter": {
-            "quoteStyle": "single",
-            "jsxQuoteStyle": "double",
-            "semicolons": "always",
-            "trailingCommas": "all",
-            "arrowParentheses": "always",
-            "bracketSpacing": true,
-            "bracketSameLine": false
-        }
-    },
-    "json": {
-        "formatter": {
-            "indentWidth": 2,
-            "trailingCommas": "none",
-            "lineWidth": 120
-        }
-    },
-    "css": {
-        "formatter": {
-            "indentWidth": 2,
-            "quoteStyle": "single"
-        }
-    },
-    "files": {
-        "includes": [
-            "**",
-            "!**/node_modules",
-            "!**/dist",
-            "!**/lib",
-            "!**/build",
-            "!**/build-dir",
-            "!**/builddir",
-            "!**/flatpak-build",
-            "!**/.flatpak-builder",
-            "!**/repo",
-            "!**/coverage",
-            "!**/refs",
-            "!**/@types",
-            "!**/templates",
-            "!**/prebuilds",
-            "!**/.yarn/cache",
-            "!**/.yarn/install-state.gz",
-            "!**/cli.gjs.mjs",
-            "!**/test.gjs.mjs",
-            "!**/test.node.mjs",
-            "!**/*.gresource",
-            "!**/*.compiled",
-            "!**/*.metainfo.xml"
-        ]
-    }
-}

package/lib/utils/biome-resolve.d.ts

@@ -1,47 +0,0 @@
-/**
- * Resolve the absolute path to the biome native binary for the current
- * platform. Walks cwd → workspace-root looking for the matching
- * `@biomejs/cli-<platform>-<arch>` package.
- *
- * Throws with a clear install-hint when not found.
- */
-export declare function findBiomeBin(cwd?: string): string;
-export declare class BiomeNotFoundError extends Error {
-    pkg: string;
-    cwd: string;
-    constructor(pkg: string, cwd: string);
-}
-/**
- * Walk up from a starting directory to find the nearest `biome.json` or
- * `biome.jsonc`. Returns absolute path or null. Workspace-aware: also
- * probes the workspace root.
- */
-export declare function findBiomeConfig(cwd?: string): string | null;
-export interface RunBiomeOptions {
-    cwd?: string;
-    verbose?: boolean;
-}
-/**
- * Spawn biome with the given args. Inherits stdio so biome's own output
- * (formatted source, lint diagnostics, summary lines) reaches the user.
- *
- * Returns the exit code as a number; never throws on non-zero exit
- * (callers check the code).
- */
-export declare function runBiome(args: string[], opts?: RunBiomeOptions): Promise<number>;
-/**
- * Lazy-load the embedded `biome.json.tmpl` content. The static-read-inliner
- * matches this readFileSync(new URL(<lit>, import.meta.url), 'utf-8')
- * shape at build time and inlines the file into the GJS bundle, so the
- * template is available without runtime file I/O against the install dir.
- */
-export declare function loadBiomeTemplate(): string;
-/** Helper for callers to surface the install hint to the user cleanly. */
-export declare function printBiomeNotFound(err: BiomeNotFoundError): void;
-/**
- * Has `@biomejs/biome` (the npm wrapper package) been declared in the
- * project's `package.json` devDependencies or dependencies? Useful as a
- * cheap pre-flight check — `gjsify flatpak init`'s G.2 post-format hook
- * uses this to decide whether to auto-format its outputs.
- */
-export declare function hasBiomeDevDep(cwd?: string): boolean;