@gjsify/cli 0.4.28 → 0.4.30

package/lib/commands/system-check.js

@@ -3,8 +3,7 @@ export const systemCheckCommand = {
     command: 'system-check',
     description: 'Check that required system dependencies (GJS, GTK4, libsoup3, …) are installed. Optional dependencies are detected only when their @gjsify/* package is in your project. (Previously called `gjsify check`; the bare name now runs TypeScript checks across the workspace — see `gjsify check --help`.)',
     builder: (yargs) => {
-        return yargs
-            .option('json', {
+        return yargs.option('json', {
             description: 'Output results as JSON',
             type: 'boolean',
             default: false,
@@ -13,8 +12,8 @@ export const systemCheckCommand = {
     handler: async (args) => {
         const results = runAllChecks(process.cwd());
         const pm = detectPackageManager();
-        const missingRequired = results.filter(r => !r.found && r.severity === 'required');
-        const missingOptional = results.filter(r => !r.found && r.severity === 'optional');
+        const missingRequired = results.filter((r) => !r.found && r.severity === 'required');
+        const missingOptional = results.filter((r) => !r.found && r.severity === 'optional');
         const allMissing = [...missingRequired, ...missingOptional];
         if (args.json) {
             console.log(JSON.stringify({ packageManager: pm, deps: results }, null, 2));
@@ -23,8 +22,8 @@ export const systemCheckCommand = {
             return;
         }
         console.log('System dependency check\n');
-        const required = results.filter(r => r.severity === 'required');
-        const optional = results.filter(r => r.severity === 'optional');
+        const required = results.filter((r) => r.severity === 'required');
+        const optional = results.filter((r) => r.severity === 'optional');
         if (required.length > 0) {
             console.log('Required:');
             for (const dep of required) {
@@ -39,9 +38,7 @@ export const systemCheckCommand = {
                 // ⚠ for missing-but-needed-by-installed-packages, ○ for missing-but-not-needed (shouldn't appear in conditional mode)
                 const icon = dep.found ? '✓' : '⚠';
                 const ver = dep.version ? `  (${dep.version})` : '';
-                const requiredBy = dep.requiredBy && dep.requiredBy.length > 0
-                    ? `  — needed by ${dep.requiredBy.join(', ')}`
-                    : '';
+                const requiredBy = dep.requiredBy && dep.requiredBy.length > 0 ? `  — needed by ${dep.requiredBy.join(', ')}` : '';
                 console.log(`  ${icon}  ${dep.name}${ver}${requiredBy}`);
             }
         }
@@ -51,10 +48,10 @@ export const systemCheckCommand = {
             return;
         }
         if (missingRequired.length > 0) {
-            console.log(`\nMissing required: ${missingRequired.map(d => d.name).join(', ')}`);
+            console.log(`\nMissing required: ${missingRequired.map((d) => d.name).join(', ')}`);
         }
         if (missingOptional.length > 0) {
-            console.log(`Missing optional: ${missingOptional.map(d => d.name).join(', ')}`);
+            console.log(`Missing optional: ${missingOptional.map((d) => d.name).join(', ')}`);
         }
         const cmd = buildInstallCommand(pm, allMissing);
         if (cmd) {

package/lib/commands/test.js

@@ -66,13 +66,15 @@ export const testCommand = {
             ? ['gjs']
             : args.runtime === 'node'
                 ? ['node']
-                : (testCfg.runtimes && testCfg.runtimes.length > 0 ? testCfg.runtimes : ['gjs', '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);
+                const needsBuild = args.rebuild || !isFresh(outfile, entry);
                 if (needsBuild) {
                     const buildStart = Date.now();
                     if (args.verbose) {
@@ -144,11 +146,11 @@ async function buildTestBundle(entry, outfile, runtime, verbose) {
     // 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.library = { ...configData.library };
     configData.bundler = {
-        ...(configData.bundler ?? {}),
+        ...configData.bundler,
         input: [entry],
-        output: { ...(configData.bundler?.output ?? {}), file: outfile },
+        output: { ...configData.bundler?.output, file: outfile },
     };
     const action = new BuildAction(configData);
     await action.start({ app: runtime, library: false });
@@ -171,7 +173,7 @@ async function runTestBundle(outfile, runtime) {
     });
 }
 /** True when `outfile` exists and is newer than every `.ts`/`.mts` file under the entry's directory tree. */
-function isFresh(outfile, entry, cwd) {
+function isFresh(outfile, entry) {
     if (!existsSync(outfile))
         return false;
     const outMtime = statSync(outfile).mtimeMs;
@@ -186,7 +188,6 @@ function isFresh(outfile, entry, cwd) {
         // On any FS error, force rebuild to stay safe.
         return false;
     }
-    void cwd;
 }
 function newestMtimeUnder(path) {
     const st = statSync(path);
@@ -194,7 +195,10 @@ function newestMtimeUnder(path) {
         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('.')) {
+        if (entry.name === 'node_modules' ||
+            entry.name === 'dist' ||
+            entry.name === 'lib' ||
+            entry.name.startsWith('.')) {
             continue;
         }
         const child = join(path, entry.name);

package/lib/commands/uninstall.d.ts

@@ -5,5 +5,5 @@ interface UninstallOptions {
     'dry-run'?: boolean;
     verbose?: boolean;
 }
-export declare const uninstallCommand: Command<any, UninstallOptions>;
+export declare const uninstallCommand: Command<unknown, UninstallOptions>;
 export {};

package/lib/commands/uninstall.js

@@ -134,9 +134,7 @@ function findBinShimsForPackage(binDir, pkgDir, verbose) {
             // Find the `exec [gjs -m] '<target>' "$@"` line; the path may
             // contain `:` from the optional prebuild preamble lines, which
             // is why we anchor to `exec ` rather than the first quoted run.
-            const execLine = content
-                .split('\n')
-                .find((line) => /^exec (?:gjs -m )?'/.test(line));
+            const execLine = content.split('\n').find((line) => /^exec (?:gjs -m )?'/.test(line));
             if (!execLine)
                 continue;
             const m = execLine.match(/'([^']+)'/);

package/lib/commands/upgrade.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "../types/index.js";
+import type { Command } from '../types/index.js';
 interface UpgradeOptions {
     latest?: boolean;
     minor?: boolean;

package/lib/commands/upgrade.js

@@ -12,104 +12,104 @@
 // 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";
+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.",
+    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",
+            .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",
+            .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",
+            .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('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",
+            .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('cwd', {
+            description: 'Project directory. Default: process.cwd().',
+            type: 'string',
         })
-            .option("yes", {
-            alias: "y",
-            description: "Interactive mode: select all without prompting.",
-            type: "boolean",
+            .option('yes', {
+            alias: 'y',
+            description: 'Interactive mode: select all without prompting.',
+            type: 'boolean',
             default: false,
         })
-            .option("verbose", {
-            description: "Print extra resolution details.",
-            type: "boolean",
+            .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");
+        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 rawPkg = readFileSync(pkgJsonPath, 'utf-8');
         const pkg = JSON.parse(rawPkg);
         const filters = args.filter
             ? args.filter
-                .split(",")
+                .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.");
+            console.log('[gjsify upgrade] no external npm dependencies to check.');
             return;
         }
         const npmrc = await loadNpmrcLight(cwd);
         const mode = args.latest
-            ? "latest"
+            ? 'latest'
             : args.minor
-                ? "minor"
+                ? 'minor'
                 : args.patch
-                    ? "patch"
-                    : "interactive";
+                    ? '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");
+            console.log('✅ all dependencies are up to date');
             return;
         }
         printTable(candidates);
         let selected;
-        if (mode === "interactive" && !args.yes) {
+        if (mode === 'interactive' && !args.yes) {
             selected = await promptSelection(candidates);
         }
-        else if (args.yes && mode === "interactive") {
-            console.log("[gjsify upgrade] -y / --yes: selecting all");
+        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.");
+            console.log('[gjsify upgrade] nothing selected; package.json unchanged.');
             return;
         }
         if (args.dryRun) {
@@ -121,34 +121,29 @@ export const upgradeCommand = {
     },
 };
 // ─── Resolution ─────────────────────────────────────────────────────────
-const DEP_FIELDS = [
-    "dependencies",
-    "devDependencies",
-    "optionalDependencies",
-    "peerDependencies",
-];
+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")
+        if (!map || typeof map !== 'object')
             continue;
         for (const [name, raw] of Object.entries(map)) {
-            if (typeof raw !== "string")
+            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") {
+            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);
@@ -171,8 +166,8 @@ function collectExternalDeps(pkg, filters) {
 function splitRange(range) {
     const m = range.match(/^(\^|~|>=|<=|>|<|=)?\s*([0-9].*)$/);
     if (!m)
-        return { prefix: "", version: null };
-    const prefix = m[1] ?? "";
+        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 };
@@ -190,7 +185,7 @@ async function resolveCandidates(entries, npmrc, verbose, mode) {
             const entry = entries[i];
             try {
                 const packument = await fetchPackument(entry.name, { npmrc });
-                const latest = packument["dist-tags"]?.latest;
+                const latest = packument['dist-tags']?.latest;
                 if (!latest) {
                     if (verbose)
                         console.warn(`  ${entry.name}: no dist-tags.latest, skipping`);
@@ -202,11 +197,11 @@ async function resolveCandidates(entries, npmrc, verbose, mode) {
                     continue;
                 }
                 const diff = classifyDiff(entry.currentVersion, latest);
-                if (diff === "none")
+                if (diff === 'none')
                     continue;
-                if (mode === "minor" && diff === "major")
+                if (mode === 'minor' && diff === 'major')
                     continue;
-                if (mode === "patch" && (diff === "major" || diff === "minor"))
+                if (mode === 'patch' && (diff === 'major' || diff === 'minor'))
                     continue;
                 results.push({
                     ...entry,
@@ -219,7 +214,6 @@ async function resolveCandidates(entries, npmrc, verbose, mode) {
                     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));
@@ -229,39 +223,39 @@ function classifyDiff(current, latest) {
     const c = parse(current);
     const l = parse(latest);
     if (!c || !l)
-        return "none";
+        return 'none';
     if (c.major !== l.major)
-        return l.major > c.major ? "major" : "none";
+        return l.major > c.major ? 'major' : 'none';
     if (c.minor !== l.minor)
-        return l.minor > c.minor ? "minor" : "none";
+        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";
+        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",
+    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":
+        case 'major':
             return ANSI.red;
-        case "minor":
+        case 'minor':
             return ANSI.yellow;
-        case "patch":
+        case 'patch':
             return ANSI.green;
-        case "prerelease":
+        case 'prerelease':
             return ANSI.cyan;
         default:
-            return "";
+            return '';
     }
 }
 function printTable(candidates) {
@@ -269,33 +263,33 @@ function printTable(candidates) {
     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) +
+    const head = ' '.repeat(idxW) +
         ANSI.bold +
-        "name".padEnd(nameW) +
-        "  " +
-        "current".padEnd(curW) +
-        "  " +
-        "latest".padEnd(newW) +
-        "  " +
-        "kind" +
+        '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);
+    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);
@@ -303,28 +297,28 @@ function printTable(candidates) {
 }
 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.");
+        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, " +
+        console.log('\nSelect upgrades: comma- or space-separated indices, ' +
             ANSI.bold +
-            "a" +
+            'a' +
             ANSI.reset +
-            " for all, ranges like " +
+            ' for all, ranges like ' +
             ANSI.bold +
-            "1-3" +
+            '1-3' +
             ANSI.reset +
-            ", or " +
+            ', or ' +
             ANSI.bold +
-            "ENTER" +
+            'ENTER' +
             ANSI.reset +
-            " to skip:");
-        const answer = (await rl.question("> ")).trim();
+            ' to skip:');
+        const answer = (await rl.question('> ')).trim();
         if (!answer)
             return [];
-        if (answer.toLowerCase() === "a" || answer.toLowerCase() === "all")
+        if (answer.toLowerCase() === 'a' || answer.toLowerCase() === 'all')
             return candidates;
         const picked = new Set();
         for (const token of answer.split(/[\s,]+/).filter(Boolean)) {
@@ -339,9 +333,7 @@ async function promptSelection(candidates) {
                 picked.add(Number(token) - 1);
             }
         }
-        return [...picked]
-            .filter((i) => i >= 0 && i < candidates.length)
-            .map((i) => candidates[i]);
+        return [...picked].filter((i) => i >= 0 && i < candidates.length).map((i) => candidates[i]);
     }
     finally {
         rl.close();
@@ -357,7 +349,7 @@ function writePackageJson(path, rawText, parsed, selected) {
         map[c.name] = c.prefix + c.latestVersion;
     }
     const indent = detectIndent(rawText);
-    writeFileSync(path, JSON.stringify(parsed, null, indent) + (rawText.endsWith("\n") ? "\n" : ""), "utf-8");
+    writeFileSync(path, JSON.stringify(parsed, null, indent) + (rawText.endsWith('\n') ? '\n' : ''), 'utf-8');
 }
 function detectIndent(json) {
     const m = json.match(/^\{\n( +)/);
@@ -377,11 +369,11 @@ async function loadNpmrcLight(cwd) {
     // 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")]) {
+    for (const candidate of [join(homedir(), '.npmrc'), join(cwd, '.npmrc')]) {
         if (!existsSync(candidate))
             continue;
         try {
-            const proj = parseNpmrc(readFileSync(candidate, "utf-8"));
+            const proj = parseNpmrc(readFileSync(candidate, 'utf-8'));
             parsed = {
                 ...parsed,
                 ...proj,
@@ -397,6 +389,3 @@ async function loadNpmrcLight(cwd) {
     }
     return parsed;
 }
-function packumentToString(p) {
-    return `${p.name}@${p["dist-tags"]?.latest ?? "?"}`;
-}

package/lib/commands/workspace.d.ts

@@ -4,5 +4,5 @@ interface WorkspaceCmdOptions {
     script: string;
     args?: string[];
 }
-export declare const workspaceCommand: Command<any, WorkspaceCmdOptions>;
+export declare const workspaceCommand: Command<unknown, WorkspaceCmdOptions>;
 export {};

package/lib/commands/workspace.js

@@ -51,9 +51,7 @@ export const workspaceCommand = {
         // on isTTY (chalk, picocolors, biome) drop colors when stdout is a
         // pipe, including GitHub Actions where the log viewer renders ANSI
         // fine.
-        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' };
         await new Promise((resolve, reject) => {
             const child = spawn(runner, argv, {
                 cwd: target.location,