@gjsify/cli 0.4.13 → 0.4.15

package/lib/commands/format.js

@@ -0,0 +1,98 @@
+// `gjsify format` — wraps biome's `format` mode.
+//
+// Resolves biome's native binary from node_modules (skipping the Node
+// launcher in @biomejs/biome/bin/biome) and spawns it directly. This
+// keeps the Node-free promise intact: biome's per-platform package
+// (e.g. @biomejs/cli-linux-x64) carries a self-contained Rust binary.
+//
+// `--init` writes a recommended biome.json template tuned for GJS/GNOME
+// projects (4-space JS/TS, 2-space JSON+CSS, single-quotes, lineWidth
+// 120, biome's recommended linter + a few GJS-specific opt-outs).
+import { existsSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { BiomeNotFoundError, findBiomeConfig, loadBiomeTemplate, printBiomeNotFound, runBiome, } from '../utils/biome-resolve.js';
+export const formatCommand = {
+    command: 'format [paths..]',
+    description: 'Format source files via Biome (native binary spawn — no Node launcher).',
+    builder: (yargs) => {
+        return yargs
+            .positional('paths', {
+            description: 'Files or directories to format. Default: `.`',
+            type: 'string',
+            array: true,
+        })
+            .option('write', {
+            description: 'Modify files in place (default: stdout / report).',
+            type: 'boolean',
+            default: false,
+        })
+            .option('check', {
+            description: 'Report formatting drift without modifying files; exit non-zero if any file is unformatted. Useful for CI.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('config-path', {
+            description: 'Path to a biome.json. Default: walks up from cwd to find one.',
+            type: 'string',
+            normalize: true,
+        })
+            .option('init', {
+            description: 'Write a recommended biome.json into cwd (skips if one exists; --force to overwrite).',
+            type: 'boolean',
+            default: false,
+        })
+            .option('force', {
+            description: 'Overwrite an existing biome.json with --init.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('verbose', {
+            description: 'Echo the resolved biome binary + args before spawning.',
+            type: 'boolean',
+            default: false,
+        });
+    },
+    handler: async (args) => {
+        const cwd = process.cwd();
+        if (args.init) {
+            await handleInit({ cwd, force: args.force ?? false });
+            return;
+        }
+        const paths = args.paths?.length
+            ? args.paths
+            : ['.'];
+        const biomeArgs = ['format'];
+        if (args.write && !args.check)
+            biomeArgs.push('--write');
+        // --check is the CI semantic: don't write, exit non-zero on drift.
+        // Biome's default mode (no --write) already reports drift + exits
+        // non-zero. We forward neither flag and let biome's defaults apply.
+        const configPath = args.configPath ?? findBiomeConfig(cwd) ?? undefined;
+        if (configPath)
+            biomeArgs.push(`--config-path=${resolve(configPath, '..')}`);
+        biomeArgs.push(...paths);
+        try {
+            const code = await runBiome(biomeArgs, { cwd, verbose: args.verbose });
+            process.exitCode = code;
+        }
+        catch (err) {
+            if (err instanceof BiomeNotFoundError) {
+                printBiomeNotFound(err);
+                process.exitCode = 1;
+                return;
+            }
+            throw err;
+        }
+    },
+};
+async function handleInit({ cwd, force }) {
+    const target = resolve(cwd, 'biome.json');
+    if (existsSync(target) && !force) {
+        console.log(`[gjsify format] biome.json exists at ${target} — pass --force to overwrite.`);
+        process.exitCode = 0;
+        return;
+    }
+    writeFileSync(target, loadBiomeTemplate(), 'utf-8');
+    console.log(`[gjsify format] wrote ${target}`);
+    console.log(`[gjsify format] Run \`gjsify format --write .\` to apply the formatter to the project.`);
+}

package/lib/commands/index.d.ts

@@ -1,4 +1,5 @@
 export * from './build.js';
+export * from './test.js';
 export * from './run.js';
 export * from './info.js';
 export * from './check.js';
@@ -17,3 +18,8 @@ export * from './publish.js';
 export * from './self-update.js';
 export * from './generate-installer.js';
 export * from './uninstall.js';
+export * from './format.js';
+export * from './lint.js';
+export * from './fix.js';
+export * from './upgrade.js';
+export * from './barrels.js';

package/lib/commands/index.js

@@ -1,4 +1,5 @@
 export * from './build.js';
+export * from './test.js';
 export * from './run.js';
 export * from './info.js';
 export * from './check.js';
@@ -17,3 +18,8 @@ export * from './publish.js';
 export * from './self-update.js';
 export * from './generate-installer.js';
 export * from './uninstall.js';
+export * from './format.js';
+export * from './lint.js';
+export * from './fix.js';
+export * from './upgrade.js';
+export * from './barrels.js';

package/lib/commands/install.js

@@ -11,9 +11,12 @@
 // subprocess flow (useful as escape-hatch for projects that hit a
 // missing native-backend feature).
 //
-// Workspace-aware install (`gjsify install` in a monorepo root with a
-// `"workspaces"` field) is Phase D.3 — for now we detect and surface a
-// clear error pointing at the in-progress work.
+// Workspace install (`gjsify install` in a monorepo root with a
+// `"workspaces"` field) hoists every workspace's externals into the root
+// `node_modules/` and symlinks `workspace:*` / `workspace:^` / `workspace:~`
+// refs to their target source. Open follow-ups (see STATUS.md "Open TODOs"):
+// per-workspace dedup of conflicting transitive version ranges (first-match
+// wins today).
 import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
 import { spawn } from 'node:child_process';
@@ -115,7 +118,7 @@ async function projectInstallNative(args) {
             'not PnP-aware yet. Use `yarn install` or set ' +
             'GJSIFY_INSTALL_BACKEND=npm.');
     }
-    // Workspace install (no args, root pkg.json has `workspaces`) — Phase D.3.
+    // Workspace install (no args, root pkg.json has `workspaces`).
     // Project-local `gjsify install <pkg>` inside a workspace child still
     // goes through the single-package code path below (this branch only
     // fires for the root no-args case, which is the `yarn install`
@@ -199,8 +202,7 @@ function syncLockfileRequested(cwd, specs) {
     }
 }
 /**
- * Phase D.3 — workspace-aware install. Mirrors what `yarn install` does
- * at a monorepo root:
+ * Workspace-aware install. Mirrors what `yarn install` does at a monorepo root:
  *   1. Discover every workspace under the root.
  *   2. Aggregate the union of their external (non-`workspace:`) deps.
  *   3. Run the native install backend ONCE at the root prefix so all
@@ -211,9 +213,9 @@ function syncLockfileRequested(cwd, specs) {
  *      directory into the requesting workspace's `node_modules/<dep>`
  *      so `import '@gjsify/utils'` resolves to the local source.
  *
- * Hoisting strategy is intentionally minimal — D.3 ships the working
- * baseline; per-workspace dedup + nested `node_modules/` for version
- * conflicts are tracked as a follow-up in STATUS.md "Open TODOs".
+ * Hoisting strategy is intentionally minimal — per-workspace dedup +
+ * nested `node_modules/` for version conflicts are tracked as a follow-up
+ * in STATUS.md "Open TODOs".
  */
 async function workspaceInstall(cwd, args) {
     const workspaces = discoverWorkspaces(cwd, { includeRoot: true });

package/lib/commands/lint.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from '../types/index.js';
+interface LintOptions {
+    paths?: string[];
+    write?: boolean;
+    configPath?: string;
+    verbose?: boolean;
+}
+export declare const lintCommand: Command<unknown, LintOptions>;
+export {};

package/lib/commands/lint.js

@@ -0,0 +1,60 @@
+// `gjsify lint` — wraps biome's `lint` mode.
+//
+// Sibling of `gjsify format`. Spawns biome from node_modules directly
+// (no Node launcher). Default behaviour: report-only. Pass `--write`
+// for biome's safe-fix mode, or use `gjsify fix` for the combined
+// format + safe-lint-fix + organize-imports surface.
+import { resolve } from 'node:path';
+import { BiomeNotFoundError, findBiomeConfig, printBiomeNotFound, runBiome, } from '../utils/biome-resolve.js';
+export const lintCommand = {
+    command: 'lint [paths..]',
+    description: 'Run Biome lint diagnostics (native binary spawn — no Node launcher).',
+    builder: (yargs) => {
+        return yargs
+            .positional('paths', {
+            description: 'Files or directories to lint. Default: `.`',
+            type: 'string',
+            array: true,
+        })
+            .option('write', {
+            description: 'Apply safe lint fixes in place.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('config-path', {
+            description: 'Path to a biome.json. Default: walks up from cwd to find one.',
+            type: 'string',
+            normalize: true,
+        })
+            .option('verbose', {
+            description: 'Echo the resolved biome binary + args before spawning.',
+            type: 'boolean',
+            default: false,
+        });
+    },
+    handler: async (args) => {
+        const cwd = process.cwd();
+        const paths = args.paths?.length
+            ? args.paths
+            : ['.'];
+        const biomeArgs = ['lint'];
+        if (args.write)
+            biomeArgs.push('--write');
+        const configPath = args.configPath ?? findBiomeConfig(cwd) ?? undefined;
+        if (configPath)
+            biomeArgs.push(`--config-path=${resolve(configPath, '..')}`);
+        biomeArgs.push(...paths);
+        try {
+            const code = await runBiome(biomeArgs, { cwd, verbose: args.verbose });
+            process.exitCode = code;
+        }
+        catch (err) {
+            if (err instanceof BiomeNotFoundError) {
+                printBiomeNotFound(err);
+                process.exitCode = 1;
+                return;
+            }
+            throw err;
+        }
+    },
+};

package/lib/commands/test.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../types/index.js';
+type Runtime = 'gjs' | 'node';
+interface TestOptions {
+    runtime?: Runtime | 'all';
+    entry?: string;
+    outdir?: string;
+    rebuild?: boolean;
+    build?: boolean;
+    verbose?: boolean;
+}
+export declare const testCommand: Command<unknown, TestOptions>;
+export {};

package/lib/commands/test.js

@@ -0,0 +1,206 @@
+// `gjsify test` — build + run + aggregate per-runtime test suite.
+//
+// Eliminates the `build:test:{gjs,node}` + `test:{gjs,node}` + `test`
+// script boilerplate that ~110 workspace packages repeat. Each package
+// just needs `src/test.mts` aggregating its `@gjsify/unit` suites; this
+// command builds it for GJS + Node and runs each output, aggregating
+// exit codes.
+import { existsSync, statSync, readdirSync } from 'node:fs';
+import { join, dirname, resolve, relative } from 'node:path';
+import { spawn } from 'node:child_process';
+import { Config } from '../config.js';
+import { BuildAction } from '../actions/build.js';
+import { runGjsBundle } from '../utils/run-gjs.js';
+export const testCommand = {
+    command: 'test',
+    description: 'Build + run the package’s `src/test.mts` suite on GJS and Node and aggregate the results. Replaces the per-package `build:test:{gjs,node}` + `test:{gjs,node}` script boilerplate.',
+    builder: (yargs) => {
+        return yargs
+            .option('runtime', {
+            description: 'Target runtime. Default: both.',
+            type: 'string',
+            choices: ['gjs', 'node', 'all'],
+            default: 'all',
+        })
+            .option('entry', {
+            description: 'Path to the test entry. Default: `src/test.mts` (or `gjsify.test.entry`).',
+            type: 'string',
+            normalize: true,
+        })
+            .option('outdir', {
+            description: 'Output directory for the built test bundles. Default: `dist/`.',
+            type: 'string',
+            normalize: true,
+        })
+            .option('rebuild', {
+            description: 'Always rebuild the test bundles, even when they look up-to-date.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('build', {
+            description: 'Build before running. Default: true (use --no-build to skip when bundles already exist).',
+            type: 'boolean',
+            default: true,
+        })
+            .option('verbose', {
+            description: 'Print resolved entry/outdir + per-step timing.',
+            type: 'boolean',
+            default: false,
+        });
+    },
+    handler: async (args) => {
+        const cwd = process.cwd();
+        // Resolve config: gjsify.test.{entry,outdir,runtimes}.
+        const cfg = new Config();
+        const configData = await cfg.forBuild({}).catch(() => ({}));
+        const testCfg = configData.test ?? {};
+        const entry = resolve(cwd, args.entry ?? testCfg.entry ?? 'src/test.mts');
+        const outdir = resolve(cwd, args.outdir ?? testCfg.outdir ?? 'dist');
+        if (!existsSync(entry)) {
+            console.error(`[gjsify test] no test entry at ${relative(cwd, entry)} — ` +
+                `add an \`src/test.mts\` that aggregates your \`@gjsify/unit\` suites, ` +
+                `or set \`gjsify.test.entry\` in package.json.`);
+            process.exit(1);
+        }
+        const requested = args.runtime === 'gjs'
+            ? ['gjs']
+            : args.runtime === 'node'
+                ? ['node']
+                : (testCfg.runtimes && testCfg.runtimes.length > 0 ? testCfg.runtimes : ['gjs', 'node']);
+        const results = [];
+        for (const runtime of requested) {
+            const outfile = join(outdir, `test.${runtime}.mjs`);
+            // Build stage (skip if --no-build OR (not --rebuild AND outfile fresher than src)).
+            if (args.build !== false) {
+                const needsBuild = args.rebuild || !isFresh(outfile, entry, cwd);
+                if (needsBuild) {
+                    const buildStart = Date.now();
+                    if (args.verbose) {
+                        console.log(`[gjsify test] building → ${relative(cwd, outfile)} (—app ${runtime})`);
+                    }
+                    try {
+                        await buildTestBundle(entry, outfile, runtime, args.verbose);
+                        if (args.verbose) {
+                            console.log(`[gjsify test] built ${runtime} in ${Date.now() - buildStart}ms`);
+                        }
+                    }
+                    catch (err) {
+                        console.error(`[gjsify test] build failed for ${runtime}:`, err.message);
+                        results.push({ runtime, ok: false, durationMs: 0, error: 'build failed' });
+                        continue;
+                    }
+                }
+                else if (args.verbose) {
+                    console.log(`[gjsify test] ${runtime}: bundle is up-to-date — skipping build (use --rebuild to force)`);
+                }
+            }
+            else if (!existsSync(outfile)) {
+                console.error(`[gjsify test] --no-build but ${relative(cwd, outfile)} doesn't exist. ` +
+                    `Build first or drop --no-build.`);
+                results.push({ runtime, ok: false, durationMs: 0, error: 'no bundle' });
+                continue;
+            }
+            // Run stage.
+            const runStart = Date.now();
+            try {
+                await runTestBundle(outfile, runtime);
+                results.push({ runtime, ok: true, durationMs: Date.now() - runStart });
+            }
+            catch (err) {
+                results.push({
+                    runtime,
+                    ok: false,
+                    durationMs: Date.now() - runStart,
+                    error: err.message,
+                });
+            }
+        }
+        // Summary + aggregate exit.
+        const summary = results
+            .map((r) => `${r.ok ? '✅' : '❌'} ${r.runtime} (${r.durationMs}ms)${r.error ? ` — ${r.error}` : ''}`)
+            .join('  ');
+        console.log(`[gjsify test] ${summary}`);
+        const anyFailed = results.some((r) => !r.ok);
+        if (anyFailed) {
+            process.exit(1);
+        }
+    },
+};
+/** Build a single test bundle in-process via `BuildAction`. */
+async function buildTestBundle(entry, outfile, runtime, verbose) {
+    const config = new Config();
+    // forBuild's interactive prompts are skipped because we pass through
+    // ArgumentsCamelCase shape with only the relevant fields.
+    const configData = await config.forBuild({
+        entryPoints: [entry],
+        outfile,
+        app: runtime,
+        verbose: verbose ?? false,
+        logLevel: 'warning',
+        exclude: [],
+    });
+    // Override bundler entry-input so gjsify.test.entry doesn't fight with
+    // gjsify.bundler.input. The build action picks `output.file` straight from
+    // the merged config; we set it explicitly here so package.json#main /
+    // bundler.output.file from the surrounding project don't redirect the
+    // bundle elsewhere.
+    configData.library = { ...(configData.library ?? {}) };
+    configData.bundler = {
+        ...(configData.bundler ?? {}),
+        input: [entry],
+        output: { ...(configData.bundler?.output ?? {}), file: outfile },
+    };
+    const action = new BuildAction(configData);
+    await action.start({ app: runtime, library: false });
+}
+/** Run a single test bundle and reject on non-zero exit. */
+async function runTestBundle(outfile, runtime) {
+    if (runtime === 'gjs') {
+        await runGjsBundle(outfile);
+        return;
+    }
+    await new Promise((resolvePromise, reject) => {
+        const child = spawn('node', [outfile], { stdio: 'inherit' });
+        child.on('error', reject);
+        child.on('exit', (code) => {
+            if (code === 0)
+                resolvePromise();
+            else
+                reject(new Error(`node exited with code ${code}`));
+        });
+    });
+}
+/** True when `outfile` exists and is newer than every `.ts`/`.mts` file under the entry's directory tree. */
+function isFresh(outfile, entry, cwd) {
+    if (!existsSync(outfile))
+        return false;
+    const outMtime = statSync(outfile).mtimeMs;
+    const srcRoot = dirname(entry);
+    // Conservative: walk the src tree once. If the package has no `src/`,
+    // fall back to entry-only check.
+    try {
+        const newest = newestMtimeUnder(existsSync(srcRoot) ? srcRoot : entry);
+        return outMtime >= newest;
+    }
+    catch {
+        // On any FS error, force rebuild to stay safe.
+        return false;
+    }
+    void cwd;
+}
+function newestMtimeUnder(path) {
+    const st = statSync(path);
+    if (st.isFile())
+        return st.mtimeMs;
+    let max = st.mtimeMs;
+    for (const entry of readdirSync(path, { withFileTypes: true })) {
+        if (entry.name === 'node_modules' || entry.name === 'dist' || entry.name === 'lib' || entry.name.startsWith('.')) {
+            continue;
+        }
+        const child = join(path, entry.name);
+        const m = newestMtimeUnder(child);
+        if (m > max)
+            max = m;
+    }
+    return max;
+}

package/lib/commands/upgrade.d.ts

@@ -0,0 +1,13 @@
+import type { Command } from "../types/index.js";
+interface UpgradeOptions {
+    latest?: boolean;
+    minor?: boolean;
+    patch?: boolean;
+    filter?: string;
+    dryRun?: boolean;
+    cwd?: string;
+    verbose?: boolean;
+    yes?: boolean;
+}
+export declare const upgradeCommand: Command<unknown, UpgradeOptions>;
+export {};