@gjsify/cli 0.4.13 → 0.4.15

package/lib/commands/upgrade.js

@@ -0,0 +1,402 @@
+// `gjsify upgrade` — drop-in replacement for `yarn upgrade-interactive`
+// and `npx npm-check-updates`. Two modes:
+//
+//   1. Interactive (default): show outdated packages, prompt user to
+//      select which ones to update (space-separated indices or `a` for
+//      all), then write the new ranges to `package.json`.
+//
+//   2. Non-interactive (`--latest` / `--minor` / `--patch` / `--filter`):
+//      bump matching packages automatically without prompting.
+//
+// Workspace-aware: `workspace:^` / `workspace:~` / `workspace:*` ranges
+// are skipped — those are the gjsify monorepo internal links and `gjsify
+// install` resolves them locally. Only external npm specs get checked
+// against the registry.
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { createInterface } from "node:readline/promises";
+import { parse } from "@gjsify/semver";
+import { DEFAULT_REGISTRY, fetchPackument, parseNpmrc, } from "@gjsify/npm-registry";
+export const upgradeCommand = {
+    command: "upgrade",
+    description: "Check the npm registry for newer versions of declared dependencies and update package.json. Interactive by default; `--latest` / `--minor` / `--patch` switch to non-interactive bulk-update mode.",
+    builder: (yargs) => {
+        return yargs
+            .option("latest", {
+            description: "Non-interactive: bump every dependency to its latest version (allows major).",
+            type: "boolean",
+            default: false,
+        })
+            .option("minor", {
+            description: "Non-interactive: bump every dependency to the latest within the same major (semver-minor + semver-patch).",
+            type: "boolean",
+            default: false,
+        })
+            .option("patch", {
+            description: "Non-interactive: bump every dependency to the latest within the same minor (semver-patch only).",
+            type: "boolean",
+            default: false,
+        })
+            .option("filter", {
+            description: "Only consider packages whose name matches this substring (case-insensitive). Repeatable; comma-separated values are split.",
+            type: "string",
+        })
+            .option("dry-run", {
+            description: "Print the upgrade plan without writing package.json.",
+            type: "boolean",
+            default: false,
+        })
+            .option("cwd", {
+            description: "Project directory. Default: process.cwd().",
+            type: "string",
+        })
+            .option("yes", {
+            alias: "y",
+            description: "Interactive mode: select all without prompting.",
+            type: "boolean",
+            default: false,
+        })
+            .option("verbose", {
+            description: "Print extra resolution details.",
+            type: "boolean",
+            default: false,
+        });
+    },
+    handler: async (args) => {
+        const cwd = resolve(args.cwd ?? process.cwd());
+        const pkgJsonPath = join(cwd, "package.json");
+        if (!existsSync(pkgJsonPath)) {
+            throw new Error(`[gjsify upgrade] no package.json at ${pkgJsonPath}`);
+        }
+        const rawPkg = readFileSync(pkgJsonPath, "utf-8");
+        const pkg = JSON.parse(rawPkg);
+        const filters = args.filter
+            ? args.filter
+                .split(",")
+                .map((s) => s.trim().toLowerCase())
+                .filter(Boolean)
+            : [];
+        const entries = collectExternalDeps(pkg, filters);
+        if (entries.length === 0) {
+            console.log("[gjsify upgrade] no external npm dependencies to check.");
+            return;
+        }
+        const npmrc = await loadNpmrcLight(cwd);
+        const mode = args.latest
+            ? "latest"
+            : args.minor
+                ? "minor"
+                : args.patch
+                    ? "patch"
+                    : "interactive";
+        console.log(`[gjsify upgrade] checking ${entries.length} dependencies against ${npmrc.registry}…`);
+        const candidates = await resolveCandidates(entries, npmrc, args.verbose ?? false, mode);
+        if (candidates.length === 0) {
+            console.log("✅ all dependencies are up to date");
+            return;
+        }
+        printTable(candidates);
+        let selected;
+        if (mode === "interactive" && !args.yes) {
+            selected = await promptSelection(candidates);
+        }
+        else if (args.yes && mode === "interactive") {
+            console.log("[gjsify upgrade] -y / --yes: selecting all");
+            selected = candidates;
+        }
+        else {
+            selected = candidates;
+        }
+        if (selected.length === 0) {
+            console.log("[gjsify upgrade] nothing selected; package.json unchanged.");
+            return;
+        }
+        if (args.dryRun) {
+            console.log(`[gjsify upgrade] --dry-run: would update ${selected.length} dependencies (no write).`);
+            return;
+        }
+        writePackageJson(pkgJsonPath, rawPkg, pkg, selected);
+        console.log(`✏️  updated ${selected.length} dependencies in ${pkgJsonPath}. Run \`gjsify install\` to apply.`);
+    },
+};
+// ─── Resolution ─────────────────────────────────────────────────────────
+const DEP_FIELDS = [
+    "dependencies",
+    "devDependencies",
+    "optionalDependencies",
+    "peerDependencies",
+];
+function collectExternalDeps(pkg, filters) {
+    const out = [];
+    for (const field of DEP_FIELDS) {
+        const map = pkg[field];
+        if (!map || typeof map !== "object")
+            continue;
+        for (const [name, raw] of Object.entries(map)) {
+            if (typeof raw !== "string")
+                continue;
+            if (filters.length && !filters.some((f) => name.toLowerCase().includes(f))) {
+                continue;
+            }
+            // Skip workspace-protocol + file: + link: + git: + http(s): specs.
+            if (raw.startsWith("workspace:") ||
+                raw.startsWith("file:") ||
+                raw.startsWith("link:") ||
+                raw.startsWith("git+") ||
+                raw.startsWith("git:") ||
+                raw.startsWith("http") ||
+                raw.startsWith("npm:") || // e.g. `foo: npm:@scope/foo@^1`
+                raw === "*" ||
+                raw === "latest") {
+                continue;
+            }
+            const { prefix, version } = splitRange(raw);
+            out.push({
+                name,
+                field,
+                currentRange: raw,
+                currentVersion: version,
+                prefix,
+            });
+        }
+    }
+    return out;
+}
+/**
+ * Split `^1.2.3` → { prefix: "^", version: "1.2.3" }. Honors `~`, `>=`,
+ * `>`, `<=`, `<`, `=`. Defaults to "" prefix when the range is just a
+ * literal version.
+ */
+function splitRange(range) {
+    const m = range.match(/^(\^|~|>=|<=|>|<|=)?\s*([0-9].*)$/);
+    if (!m)
+        return { prefix: "", version: null };
+    const prefix = m[1] ?? "";
+    const version = m[2]?.split(/\s|[|&,]/)[0] ?? null; // strip range modifiers (`||`, ` - `, etc.)
+    const parsed = version ? parse(version) : null;
+    return { prefix, version: parsed?.version ?? null };
+}
+async function resolveCandidates(entries, npmrc, verbose, mode) {
+    const results = [];
+    // Parallel fetch with a small concurrency cap.
+    const cap = 8;
+    let cursor = 0;
+    async function worker() {
+        for (;;) {
+            const i = cursor++;
+            if (i >= entries.length)
+                return;
+            const entry = entries[i];
+            try {
+                const packument = await fetchPackument(entry.name, { npmrc });
+                const latest = packument["dist-tags"]?.latest;
+                if (!latest) {
+                    if (verbose)
+                        console.warn(`  ${entry.name}: no dist-tags.latest, skipping`);
+                    continue;
+                }
+                if (!entry.currentVersion) {
+                    if (verbose)
+                        console.warn(`  ${entry.name}: unable to parse current range "${entry.currentRange}"`);
+                    continue;
+                }
+                const diff = classifyDiff(entry.currentVersion, latest);
+                if (diff === "none")
+                    continue;
+                if (mode === "minor" && diff === "major")
+                    continue;
+                if (mode === "patch" && (diff === "major" || diff === "minor"))
+                    continue;
+                results.push({
+                    ...entry,
+                    latestVersion: latest,
+                    diff,
+                });
+            }
+            catch (err) {
+                if (verbose)
+                    console.warn(`  ${entry.name}: fetch failed (${err.message})`);
+            }
+        }
+        void packumentToString;
+    }
+    await Promise.all(Array.from({ length: cap }, () => worker()));
+    results.sort((a, b) => a.name.localeCompare(b.name));
+    return results;
+}
+function classifyDiff(current, latest) {
+    const c = parse(current);
+    const l = parse(latest);
+    if (!c || !l)
+        return "none";
+    if (c.major !== l.major)
+        return l.major > c.major ? "major" : "none";
+    if (c.minor !== l.minor)
+        return l.minor > c.minor ? "minor" : "none";
+    if (c.patch !== l.patch)
+        return l.patch > c.patch ? "patch" : "none";
+    if ((c.prerelease ?? []).join(".") !== (l.prerelease ?? []).join("."))
+        return "prerelease";
+    return "none";
+}
+// ─── Output / Interaction ──────────────────────────────────────────────
+const ANSI = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    green: "\x1b[32m",
+    cyan: "\x1b[36m",
+};
+function colorForDiff(diff) {
+    switch (diff) {
+        case "major":
+            return ANSI.red;
+        case "minor":
+            return ANSI.yellow;
+        case "patch":
+            return ANSI.green;
+        case "prerelease":
+            return ANSI.cyan;
+        default:
+            return "";
+    }
+}
+function printTable(candidates) {
+    const nameW = Math.max(...candidates.map((c) => c.name.length), 4);
+    const curW = Math.max(...candidates.map((c) => c.currentRange.length), 7);
+    const newW = Math.max(...candidates.map((c) => c.latestVersion.length), 6);
+    const idxW = String(candidates.length).length + 2;
+    const head = " ".repeat(idxW) +
+        ANSI.bold +
+        "name".padEnd(nameW) +
+        "  " +
+        "current".padEnd(curW) +
+        "  " +
+        "latest".padEnd(newW) +
+        "  " +
+        "kind" +
+        ANSI.reset;
+    console.log(head);
+    console.log(" ".repeat(idxW) + ANSI.dim + "─".repeat(nameW + curW + newW + 12) + ANSI.reset);
+    for (let i = 0; i < candidates.length; i++) {
+        const c = candidates[i];
+        const idx = `${i + 1}.`.padEnd(idxW);
+        const color = colorForDiff(c.diff);
+        console.log(idx +
+            c.name.padEnd(nameW) +
+            "  " +
+            ANSI.dim +
+            c.currentRange.padEnd(curW) +
+            ANSI.reset +
+            "  " +
+            color +
+            c.latestVersion.padEnd(newW) +
+            ANSI.reset +
+            "  " +
+            color +
+            c.diff +
+            ANSI.reset);
+    }
+}
+async function promptSelection(candidates) {
+    if (!process.stdin.isTTY) {
+        console.log("[gjsify upgrade] non-TTY stdin: pass --latest / --minor / --patch (or --yes for interactive-all) to upgrade non-interactively.");
+        return [];
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log("\nSelect upgrades: comma- or space-separated indices, " +
+            ANSI.bold +
+            "a" +
+            ANSI.reset +
+            " for all, ranges like " +
+            ANSI.bold +
+            "1-3" +
+            ANSI.reset +
+            ", or " +
+            ANSI.bold +
+            "ENTER" +
+            ANSI.reset +
+            " to skip:");
+        const answer = (await rl.question("> ")).trim();
+        if (!answer)
+            return [];
+        if (answer.toLowerCase() === "a" || answer.toLowerCase() === "all")
+            return candidates;
+        const picked = new Set();
+        for (const token of answer.split(/[\s,]+/).filter(Boolean)) {
+            const range = token.match(/^(\d+)-(\d+)$/);
+            if (range) {
+                const a = Number(range[1]);
+                const b = Number(range[2]);
+                for (let i = Math.min(a, b); i <= Math.max(a, b); i++)
+                    picked.add(i - 1);
+            }
+            else if (/^\d+$/.test(token)) {
+                picked.add(Number(token) - 1);
+            }
+        }
+        return [...picked]
+            .filter((i) => i >= 0 && i < candidates.length)
+            .map((i) => candidates[i]);
+    }
+    finally {
+        rl.close();
+    }
+}
+// ─── Write-back ────────────────────────────────────────────────────────
+function writePackageJson(path, rawText, parsed, selected) {
+    // Mutate the parsed object then re-stringify with the original indent.
+    for (const c of selected) {
+        const map = parsed[c.field];
+        if (!map)
+            continue;
+        map[c.name] = c.prefix + c.latestVersion;
+    }
+    const indent = detectIndent(rawText);
+    writeFileSync(path, JSON.stringify(parsed, null, indent) + (rawText.endsWith("\n") ? "\n" : ""), "utf-8");
+}
+function detectIndent(json) {
+    const m = json.match(/^\{\n( +)/);
+    if (m)
+        return m[1].length;
+    return 2;
+}
+// ─── npmrc loader (lightweight, shared shape with install-backend) ─────
+async function loadNpmrcLight(cwd) {
+    let parsed = {
+        registry: DEFAULT_REGISTRY,
+        scopes: {},
+        authTokens: {},
+        basicAuth: {},
+    };
+    // Layered .npmrc lookup (most-specific wins): home → cwd. Same precedence
+    // as install-backend-native, except env-var `npm_config_registry` wins
+    // over file values (matches npm's real semantics, lets the test harness
+    // point at a mock registry without touching `~/.npmrc`).
+    for (const candidate of [join(homedir(), ".npmrc"), join(cwd, ".npmrc")]) {
+        if (!existsSync(candidate))
+            continue;
+        try {
+            const proj = parseNpmrc(readFileSync(candidate, "utf-8"));
+            parsed = {
+                ...parsed,
+                ...proj,
+                scopes: { ...parsed.scopes, ...proj.scopes },
+            };
+        }
+        catch {
+            // ignore malformed .npmrc — same lenient policy as install-backend
+        }
+    }
+    if (process.env.npm_config_registry) {
+        parsed.registry = process.env.npm_config_registry;
+    }
+    return parsed;
+}
+function packumentToString(p) {
+    return `${p.name}@${p["dist-tags"]?.latest ?? "?"}`;
+}

package/lib/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import { buildCommand as build, runCommand as run, infoCommand as info, checkCommand as check, showcaseCommand as showcase, createCommand as create, gresourceCommand as gresource, gettextCommand as gettext, gsettingsCommand as gsettings, flatpakCommand as flatpak, dlxCommand as dlx, installCommand as install, foreachCommand as foreach, workspaceCommand as workspace, packCommand as pack, publishCommand as publish, selfUpdateCommand as selfUpdate, generateInstallerCommand as generateInstaller, uninstallCommand as uninstall, } from './commands/index.js';
+import { buildCommand as build, testCommand as test, runCommand as run, infoCommand as info, checkCommand as check, showcaseCommand as showcase, createCommand as create, gresourceCommand as gresource, gettextCommand as gettext, gsettingsCommand as gsettings, flatpakCommand as flatpak, dlxCommand as dlx, installCommand as install, foreachCommand as foreach, workspaceCommand as workspace, packCommand as pack, publishCommand as publish, selfUpdateCommand as selfUpdate, generateInstallerCommand as generateInstaller, uninstallCommand as uninstall, formatCommand as format, lintCommand as lint, fixCommand as fix, upgradeCommand as upgrade, barrelsCommand as barrels, } from './commands/index.js';
 import { APP_NAME } from './constants.js';
 // `parseAsync()` instead of `.argv` so the top-level await keeps the
 // process alive until command handlers complete. Under Node this is
@@ -14,6 +14,7 @@ await yargs(hideBin(process.argv))
     .command(create.command, create.description, create.builder, create.handler)
     .command(install.command, install.description, install.builder, install.handler)
     .command(build.command, build.description, build.builder, build.handler)
+    .command(test.command, test.description, test.builder, test.handler)
     .command(run.command, run.description, run.builder, run.handler)
     .command(dlx.command, dlx.description, dlx.builder, dlx.handler)
     .command(info.command, info.description, info.builder, info.handler)
@@ -30,6 +31,11 @@ await yargs(hideBin(process.argv))
     .command(selfUpdate.command, selfUpdate.description, selfUpdate.builder, selfUpdate.handler)
     .command(generateInstaller.command, generateInstaller.description, generateInstaller.builder, generateInstaller.handler)
     .command(uninstall.command, uninstall.description, uninstall.builder, uninstall.handler)
+    .command(upgrade.command, upgrade.description, upgrade.builder, upgrade.handler)
+    .command(format.command, format.description, format.builder, format.handler)
+    .command(lint.command, lint.description, lint.builder, lint.handler)
+    .command(fix.command, fix.description, fix.builder, fix.handler)
+    .command(barrels.command, barrels.description, barrels.builder, barrels.handler)
     .demandCommand(1)
     .help()
     .parseAsync();

package/lib/templates/biome.json.tmpl

@@ -0,0 +1,79 @@
+{
+    "$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/types/cli-build-options.d.ts

@@ -96,4 +96,11 @@ export interface CliBuildOptions {
      * Example: `--exclude-globals fetch,XMLHttpRequest`
      */
     excludeGlobals?: string[];
+    /**
+     * Watch source files and rebuild on change. Logs each rebuild with
+     * duration; SIGINT/SIGTERM cleanly closes the watcher. Only valid with
+     * `--app gjs|node|browser` (rejected with `--library`). Requires the
+     * npm `rolldown` engine — run under Node.
+     */
+    watch?: boolean;
 }

package/lib/types/config-data.d.ts

@@ -186,6 +186,38 @@ export interface ConfigData {
      * declaratively. CLI flags override these values.
      */
     flatpak?: ConfigDataFlatpak;
+    /**
+     * Format/lint config consumed by `gjsify format` / `gjsify lint` /
+     * `gjsify fix`. Thin shell — Biome's own `biome.json` is the real
+     * configuration file; we only need a pointer here.
+     */
+    format?: ConfigDataFormat;
+    /**
+     * Test-runner configuration consumed by `gjsify test`. CLI flags
+     * (--entry, --outdir, --runtime) override these values.
+     */
+    test?: ConfigDataTest;
+}
+/** Optional pointer to a non-default biome.json. */
+export interface ConfigDataFormat {
+    /**
+     * Path to biome.json. Default: walks up from cwd to find one;
+     * falls back to the recommended template shipped with `gjsify`
+     * (writable via `gjsify format --init`).
+     */
+    configPath?: string;
+}
+/**
+ * `gjsify test` configuration. All fields optional — sensible defaults
+ * apply when missing.
+ */
+export interface ConfigDataTest {
+    /** Path to the test entry. Default: `src/test.mts`. */
+    entry?: string;
+    /** Output directory for the built test bundles. Default: `dist/`. */
+    outdir?: string;
+    /** Default runtimes when `--runtime` not specified. Default: `['gjs', 'node']`. */
+    runtimes?: Array<'gjs' | 'node'>;
 }
 /**
  * Flatpak-toolchain config consumed by the `gjsify flatpak` subcommand
@@ -417,6 +449,13 @@ export interface ConfigDataFlatpak {
         displayLengthMin?: number;
         controls?: Array<'keyboard' | 'pointing' | 'touch' | 'gamepad' | 'tablet' | 'console'>;
     };
+    /**
+     * Flathub tracking-repo override for `gjsify flatpak sync-flathub` /
+     * `gjsify flatpak diff`. Default: `flathub/<appId>` (e.g.
+     * `flathub/eu.jumplink.Learn6502`). Set this when the upstream repo
+     * deviates from that convention.
+     */
+    flathubRepo?: string;
 }
 /**
  * A single block inside a MetaInfo `<description>`. Either a paragraph

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

@@ -0,0 +1,47 @@
+/**
+ * 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;