@gjsify/cli 0.4.12 → 0.4.14

package/lib/commands/flatpak/release.js

@@ -0,0 +1,152 @@
+// `gjsify flatpak release` — orchestrate the full release-to-Flathub flow.
+//
+// One command chains the same steps a maintainer otherwise runs by hand
+// after cutting a release:
+//   1. Regenerate Flathub assets from `gjsify.flatpak` config (delegates to
+//      `gjsify flatpak init --force`)
+//   2. Run Flathub linters (delegates to `gjsify flatpak check`)
+//   3. Create + push the git tag (unless `--skip-tag`)
+//   4. Sync the per-app Flathub tracking-repo (delegates to
+//      `gjsify flatpak sync-flathub`)
+//
+// Each step shells out to the same CLI binary so the user sees identical
+// behaviour to running the sub-commands directly. The orchestrator
+// stops at the first failure and reports which step blocked, with a
+// clear command the user can re-run by hand.
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import { resolve, dirname } from 'node:path';
+const execFileAsync = promisify(execFile);
+export const flatpakReleaseCommand = {
+    command: 'release <version>',
+    description: 'Cut a release end-to-end: regenerate Flathub assets, run linters, create + push the git tag, then open the Flathub PR. Each step delegates to the equivalent `gjsify flatpak <sub>` command.',
+    builder: (yargs) => {
+        return yargs
+            // yargs' built-in `--version` flag would otherwise consume the
+            // positional value.
+            .version(false)
+            .positional('version', {
+            description: 'Release tag, e.g. `v0.6.6`.',
+            type: 'string',
+            demandOption: true,
+        })
+            .option('skip-init', {
+            description: 'Skip the `flatpak init --force` regen step.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('skip-check', {
+            description: 'Skip the `flatpak check` linter step.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('skip-tag', {
+            description: 'Skip the `git tag` + `git push --tags` step (use when the tag was already created out-of-band).',
+            type: 'boolean',
+            default: false,
+        })
+            .option('push-tag', {
+            description: 'Push the created tag after creating it. Default: true.',
+            type: 'boolean',
+            default: true,
+        })
+            .option('flathub-repo', {
+            description: 'Flathub tracking-repo override forwarded to sync-flathub.',
+            type: 'string',
+        })
+            .option('dry-run', {
+            description: 'Print each step that would run without executing any of them.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('verbose', {
+            description: 'Echo every sub-command invocation.',
+            type: 'boolean',
+            default: false,
+        });
+    },
+    handler: async (args) => {
+        const version = typeof args.version === 'string' ? args.version.trim() : '';
+        if (!version) {
+            throw new Error('[gjsify flatpak release] missing <version> positional');
+        }
+        const cliEntry = resolveCliEntry();
+        const cwd = process.cwd();
+        const steps = [];
+        if (!args.skipInit) {
+            steps.push({ name: 'init', args: [cliEntry, 'flatpak', 'init', '--force'] });
+        }
+        if (!args.skipCheck) {
+            steps.push({ name: 'check', args: [cliEntry, 'flatpak', 'check'] });
+        }
+        const syncArgs = [cliEntry, 'flatpak', 'sync-flathub', '--version', version];
+        if (args.flathubRepo)
+            syncArgs.push('--flathub-repo', args.flathubRepo);
+        if (args.verbose)
+            syncArgs.push('--verbose');
+        console.log(`[gjsify flatpak release] starting release of ${version}`);
+        if (args.dryRun) {
+            console.log('[gjsify flatpak release] --dry-run set; printing plan only:');
+            for (const s of steps)
+                console.log(`  · ${s.name}: node ${s.args.join(' ')}`);
+            if (!args.skipTag)
+                console.log(`  · tag: git tag ${version}${args.pushTag !== false ? ' && git push origin ' + version : ''}`);
+            console.log(`  · sync: node ${syncArgs.join(' ')}`);
+            return;
+        }
+        // Run init + check in sequence (must succeed before any git mutation).
+        for (const step of steps) {
+            if (args.verbose)
+                console.log(`[gjsify flatpak release] step ${step.name}: node ${step.args.join(' ')}`);
+            await runNode(step.args, cwd);
+            console.log(`[gjsify flatpak release] ${step.name} ✔`);
+        }
+        // Tag creation — only after init + check succeed so we don't end up
+        // with a tag pointing at a broken release.
+        if (!args.skipTag) {
+            if (args.verbose)
+                console.log(`[gjsify flatpak release] git tag ${version}`);
+            try {
+                await execFileAsync('git', ['tag', version], { cwd });
+                console.log(`[gjsify flatpak release] tag ${version} created`);
+            }
+            catch (err) {
+                throw new Error(`[gjsify flatpak release] git tag failed (${err.message}). ` +
+                    `If the tag already exists, re-run with --skip-tag.`);
+            }
+            if (args.pushTag !== false) {
+                if (args.verbose)
+                    console.log(`[gjsify flatpak release] git push origin ${version}`);
+                await execFileAsync('git', ['push', 'origin', version], { cwd });
+                console.log(`[gjsify flatpak release] tag pushed`);
+            }
+        }
+        // Sync flathub last.
+        if (args.verbose)
+            console.log(`[gjsify flatpak release] sync: node ${syncArgs.join(' ')}`);
+        await runNode(syncArgs, cwd);
+        console.log(`[gjsify flatpak release] ✅ release ${version} complete`);
+    },
+};
+/** Resolve a path to the gjsify CLI entry to invoke sub-commands. */
+function resolveCliEntry() {
+    // `commands/flatpak/release.ts` → compiled into
+    // `lib/commands/flatpak/release.js`. The CLI entry is `lib/index.js`.
+    const here = fileURLToPath(import.meta.url);
+    const cliRoot = resolve(dirname(here), '..', '..');
+    return resolve(cliRoot, 'index.js');
+}
+/** Spawn `node <args>` and reject on non-zero exit. */
+async function runNode(args, cwd) {
+    await new Promise((resolvePromise, reject) => {
+        const child = spawn('node', args, { cwd, stdio: 'inherit' });
+        child.on('error', reject);
+        child.on('exit', (code) => {
+            if (code === 0)
+                resolvePromise();
+            else
+                reject(new Error(`sub-command exited with code ${code}: node ${args.join(' ')}`));
+        });
+    });
+}

package/lib/commands/flatpak/sync-flathub.d.ts

@@ -0,0 +1,26 @@
+import type { Command } from '../../types/index.js';
+interface SyncFlathubOptions {
+    version?: string;
+    appId?: string;
+    flathubRepo?: string;
+    commit?: string;
+    branch?: string;
+    sourceIndex?: number;
+    pr?: boolean;
+    dryRun?: boolean;
+    verbose?: boolean;
+}
+export declare const flatpakSyncFlathubCommand: Command<unknown, SyncFlathubOptions>;
+/**
+ * Surgically edit a Flathub manifest to update the git source's `tag` +
+ * `commit` (and inject `x-checker-data` if missing). Preserves the
+ * original indent + whitespace + key ordering of the surrounding JSON
+ * by parsing through JSON.parse + re-stringifying with the detected
+ * indent.
+ */
+export declare function editManifest(original: string, args: {
+    tag: string;
+    commit: string;
+    sourceIndex?: number;
+}): string;
+export {};

package/lib/commands/flatpak/sync-flathub.js

@@ -0,0 +1,311 @@
+// `gjsify flatpak sync-flathub` — sync the per-app Flathub tracking-repo.
+//
+// Flathub distributes each app via a separate `flathub/<app-id>` repo
+// whose manifest pins a specific git tag + commit-SHA of the upstream
+// source. After cutting a new release in the source repo, the Flathub
+// repo's manifest needs to be updated to reference the new tag/commit.
+// This command automates that workflow:
+//
+//   1. Resolve appId + flathub-repo (from gjsify.flatpak config / flags)
+//   2. Resolve --version (explicit flag or `git describe --tags --abbrev=0`)
+//   3. Resolve commit SHA via `git rev-list -n 1 <version>`
+//   4. Clone (or update) the flathub tracking-repo into $XDG_CACHE_HOME
+//   5. Surgically edit the manifest: modules[].sources[].{tag,commit}
+//      plus x-checker-data block (inject if missing)
+//   6. Create a branch, commit the changes
+//   7. (unless --no-pr) push + open a PR via `gh pr create`
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { Config } from '../../config.js';
+import { readPackageJson } from './utils.js';
+const execFileAsync = promisify(execFile);
+export const flatpakSyncFlathubCommand = {
+    command: 'sync-flathub',
+    description: 'Update the per-app Flathub tracking-repo manifest to a new git tag + commit. Clones, edits, commits, optionally opens a PR.',
+    builder: (yargs) => {
+        return yargs
+            // Disable yargs' built-in `--version` (which would otherwise
+            // print the package version) so this command's `--version
+            // <tag>` flag works.
+            .version(false)
+            .option('version', {
+            description: 'Git tag to sync to. Default: `git describe --tags --abbrev=0` in cwd.',
+            type: 'string',
+        })
+            .option('app-id', {
+            description: 'Reverse-DNS app id. Default: `gjsify.flatpak.appId`.',
+            type: 'string',
+        })
+            .option('flathub-repo', {
+            description: 'Flathub tracking-repo (owner/name). Default: `flathub/<appId>`.',
+            type: 'string',
+        })
+            .option('commit', {
+            description: 'Commit SHA to pin. Default: resolved via `git rev-list -n 1 <version>` in cwd.',
+            type: 'string',
+        })
+            .option('branch', {
+            description: 'Branch name in the flathub-repo. Default: `update-to-<version>`.',
+            type: 'string',
+        })
+            .option('source-index', {
+            description: 'Index into modules[0].sources[] to update (when manifest has multiple sources). Default: first `type: git` source.',
+            type: 'number',
+        })
+            .option('pr', {
+            description: 'After commit + push, open a PR via `gh pr create`. Pass `--no-pr` to skip and stop after push.',
+            type: 'boolean',
+            default: true,
+        })
+            .option('dry-run', {
+            description: 'Show what would be edited; touch no files, run no git commands.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('verbose', {
+            description: 'Echo every git / gh invocation before running.',
+            type: 'boolean',
+            default: false,
+        });
+    },
+    handler: async (args) => {
+        const cwd = process.cwd();
+        const cfg = new Config();
+        const configData = await cfg.forBuild({}).catch(() => ({}));
+        const flatpak = configData.flatpak ?? {};
+        const appId = args.appId ??
+            flatpak.appId ??
+            readPackageJson(cwd).name;
+        if (!appId) {
+            throw new Error('[gjsify flatpak sync-flathub] no app id available — pass --app-id or set gjsify.flatpak.appId.');
+        }
+        const flathubRepo = args.flathubRepo ??
+            flatpak.flathubRepo ??
+            `flathub/${appId}`;
+        const version = args.version ?? (await resolveLatestTag(cwd, args.verbose));
+        if (!version) {
+            throw new Error('[gjsify flatpak sync-flathub] no version resolved — pass --version vX.Y.Z or create a git tag locally.');
+        }
+        const commitSha = args.commit ?? (await resolveCommitForTag(cwd, version, args.verbose));
+        const branch = args.branch ?? `update-to-${normaliseBranchSegment(version)}`;
+        console.log(`[gjsify flatpak sync-flathub] appId=${appId}`);
+        console.log(`[gjsify flatpak sync-flathub] flathubRepo=${flathubRepo}`);
+        console.log(`[gjsify flatpak sync-flathub] version=${version}`);
+        console.log(`[gjsify flatpak sync-flathub] commit=${commitSha}`);
+        console.log(`[gjsify flatpak sync-flathub] branch=${branch}`);
+        if (args.dryRun) {
+            console.log(`[gjsify flatpak sync-flathub] --dry-run set; not cloning / writing / pushing.`);
+            return;
+        }
+        const cacheRoot = flathubCacheRoot();
+        const cloneDir = join(cacheRoot, flathubRepo.replace('/', '__'));
+        mkdirSync(cacheRoot, { recursive: true });
+        await ensureClone(cloneDir, flathubRepo, args.verbose);
+        const manifestPath = join(cloneDir, `${appId}.json`);
+        if (!existsSync(manifestPath)) {
+            throw new Error(`[gjsify flatpak sync-flathub] Flathub manifest not found at ${manifestPath} — wrong appId / wrong flathub-repo?`);
+        }
+        const original = readFileSync(manifestPath, 'utf-8');
+        const updated = editManifest(original, {
+            tag: version,
+            commit: commitSha,
+            sourceIndex: args.sourceIndex,
+        });
+        if (updated === original) {
+            console.log(`[gjsify flatpak sync-flathub] manifest already at ${version} — nothing to do.`);
+            return;
+        }
+        writeFileSync(manifestPath, updated, 'utf-8');
+        console.log(`[gjsify flatpak sync-flathub] manifest patched at ${manifestPath}`);
+        await gitInRepo(cloneDir, ['checkout', '-B', branch], args.verbose);
+        await gitInRepo(cloneDir, ['add', '.'], args.verbose);
+        await gitInRepo(cloneDir, ['commit', '-m', `Update to ${version}`], args.verbose);
+        if (args.pr === false) {
+            console.log(`[gjsify flatpak sync-flathub] --no-pr set; branch ${branch} committed locally in ${cloneDir}.`);
+            return;
+        }
+        await gitInRepo(cloneDir, ['push', '-u', 'origin', branch, '--force-with-lease'], args.verbose);
+        const prBody = `Auto-generated by \`gjsify flatpak sync-flathub\`.\n\n- Version: \`${version}\`\n- Commit: \`${commitSha}\`\n`;
+        await ghCreate(cloneDir, flathubRepo, branch, version, prBody, args.verbose);
+    },
+};
+// ─── Internal helpers ────────────────────────────────────────────────────
+async function resolveLatestTag(cwd, verbose) {
+    try {
+        const { stdout } = await execFileAsync('git', ['describe', '--tags', '--abbrev=0'], { cwd });
+        if (verbose)
+            console.log(`[gjsify flatpak sync-flathub] resolved latest tag → ${stdout.trim()}`);
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveCommitForTag(cwd, tag, verbose) {
+    try {
+        const { stdout } = await execFileAsync('git', ['rev-list', '-n', '1', tag], { cwd });
+        const sha = stdout.trim();
+        if (!sha)
+            throw new Error(`empty rev-list output`);
+        if (verbose)
+            console.log(`[gjsify flatpak sync-flathub] resolved ${tag} → ${sha}`);
+        return sha;
+    }
+    catch (err) {
+        throw new Error(`[gjsify flatpak sync-flathub] tag ${tag} not found locally. Run \`git fetch --tags\` or pass --commit <sha>.\n` +
+            `  underlying error: ${err?.message ?? err}`);
+    }
+}
+function normaliseBranchSegment(version) {
+    return version.replace(/^v/, '').replace(/[^A-Za-z0-9._-]/g, '-');
+}
+function flathubCacheRoot() {
+    const base = process.env.XDG_CACHE_HOME || join(homedir(), '.cache');
+    return join(base, 'gjsify', 'flathub-sync');
+}
+async function ensureClone(cloneDir, flathubRepo, verbose) {
+    if (existsSync(join(cloneDir, '.git'))) {
+        if (verbose)
+            console.log(`[gjsify flatpak sync-flathub] reusing clone at ${cloneDir}`);
+        // Hard-reset to remote HEAD to clear stale state from a previous run
+        await gitInRepo(cloneDir, ['fetch', 'origin'], verbose);
+        const defaultBranch = await detectDefaultBranch(cloneDir, verbose);
+        await gitInRepo(cloneDir, ['checkout', defaultBranch], verbose);
+        await gitInRepo(cloneDir, ['reset', '--hard', `origin/${defaultBranch}`], verbose);
+        return;
+    }
+    mkdirSync(resolve(cloneDir, '..'), { recursive: true });
+    const url = `https://github.com/${flathubRepo}.git`;
+    if (verbose)
+        console.log(`[gjsify flatpak sync-flathub] git clone ${url} ${cloneDir}`);
+    try {
+        await execFileAsync('git', ['clone', url, cloneDir]);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT') {
+            throw new Error('[gjsify flatpak sync-flathub] `git` not found. Install git from your distro (Fedora: `dnf install git`, Debian: `apt install git`).');
+        }
+        throw err;
+    }
+}
+async function detectDefaultBranch(cloneDir, verbose) {
+    // Most flathub repos use `master`; some newer ones use `main`. Probe
+    // via `git remote show` which surfaces the HEAD branch.
+    try {
+        const { stdout } = await execFileAsync('git', ['remote', 'show', 'origin'], { cwd: cloneDir });
+        const m = stdout.match(/HEAD branch: (\S+)/);
+        if (m && m[1] && m[1] !== '(unknown)') {
+            if (verbose)
+                console.log(`[gjsify flatpak sync-flathub] default branch → ${m[1]}`);
+            return m[1];
+        }
+    }
+    catch {
+        // fall through to master fallback
+    }
+    return 'master';
+}
+function gitInRepo(cwd, args, verbose) {
+    if (verbose)
+        console.log(`[gjsify flatpak sync-flathub] git ${args.join(' ')} (in ${cwd})`);
+    return new Promise((res, rej) => {
+        const child = spawn('git', args, { cwd, stdio: 'inherit' });
+        child.on('error', (err) => {
+            if (err.code === 'ENOENT') {
+                rej(new Error('[gjsify flatpak sync-flathub] `git` not found. Install it from your distro.'));
+            }
+            else {
+                rej(err);
+            }
+        });
+        child.on('exit', (code) => {
+            if (code === 0)
+                res();
+            else
+                rej(new Error(`git ${args[0]} exited ${code}`));
+        });
+    });
+}
+function ghCreate(cloneDir, flathubRepo, branch, version, body, verbose) {
+    const args = [
+        'pr',
+        'create',
+        '--repo',
+        flathubRepo,
+        '--head',
+        branch,
+        '--title',
+        `Update to ${version}`,
+        '--body',
+        body,
+    ];
+    if (verbose)
+        console.log(`[gjsify flatpak sync-flathub] gh ${args.join(' ')} (in ${cloneDir})`);
+    return new Promise((res, rej) => {
+        const child = spawn('gh', args, { cwd: cloneDir, stdio: 'inherit' });
+        child.on('error', (err) => {
+            if (err.code === 'ENOENT') {
+                rej(new Error('[gjsify flatpak sync-flathub] `gh` (GitHub CLI) not found. Install via `dnf install gh` (Fedora), `apt install gh` (Debian/Ubuntu), or `flatpak install -y flathub com.github.cli`.'));
+            }
+            else {
+                rej(err);
+            }
+        });
+        child.on('exit', (code) => {
+            if (code === 0)
+                res();
+            else
+                rej(new Error(`gh pr create exited ${code}`));
+        });
+    });
+}
+/**
+ * Surgically edit a Flathub manifest to update the git source's `tag` +
+ * `commit` (and inject `x-checker-data` if missing). Preserves the
+ * original indent + whitespace + key ordering of the surrounding JSON
+ * by parsing through JSON.parse + re-stringifying with the detected
+ * indent.
+ */
+export function editManifest(original, args) {
+    const manifest = JSON.parse(original);
+    const modules = manifest.modules ?? [];
+    if (modules.length === 0) {
+        throw new Error('[gjsify flatpak sync-flathub] manifest has no modules');
+    }
+    const mainModule = modules[0];
+    const sources = mainModule.sources ?? [];
+    if (sources.length === 0) {
+        throw new Error('[gjsify flatpak sync-flathub] modules[0] has no sources');
+    }
+    let idx = args.sourceIndex ?? sources.findIndex((s) => s.type === 'git');
+    if (idx < 0 || idx >= sources.length) {
+        throw new Error(`[gjsify flatpak sync-flathub] no git source found in modules[0].sources (use --source-index <n>)`);
+    }
+    const source = sources[idx];
+    if (source.type !== 'git') {
+        throw new Error(`[gjsify flatpak sync-flathub] modules[0].sources[${idx}].type is "${source.type}", expected "git"`);
+    }
+    source.tag = args.tag;
+    source.commit = args.commit;
+    if (!source['x-checker-data']) {
+        source['x-checker-data'] = {
+            type: 'git',
+            'tag-pattern': '^v(\\d+\\.\\d+\\.\\d+)$',
+            'version-scheme': 'semantic',
+        };
+    }
+    // Detect the original indent (2 vs 4 spaces) by inspecting the second
+    // line — Flathub manifests are all 2-space in practice, but some
+    // older ones might be 4. Preserve original convention.
+    const indent = detectIndent(original);
+    return JSON.stringify(manifest, null, indent) + (original.endsWith('\n') ? '\n' : '');
+}
+function detectIndent(json) {
+    const match = json.match(/^\{\n( +)/);
+    if (match)
+        return match[1].length;
+    return 2;
+}

package/lib/commands/format.d.ts

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

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,7 @@ 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';

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,7 @@ 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';

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 {};