@rsuvarna/pkgsort 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+Once releases begin, this file is generated from
+[Changesets](https://github.com/changesets/changesets); do not edit released
+sections by hand.
+
+## [Unreleased]
+
+### Added
+
+- Repository foundation: documentation (PRD, Architecture, Roadmap, Config
+  reference), README, and community health files (Contributing, Code of
+  Conduct, License).
+- Tooling baseline: TypeScript (strict), ESLint (typed) + Prettier, Vitest with
+  coverage thresholds.
+- Continuous integration: lint/typecheck/format gates and a test matrix across
+  Node 22 and 24 on Linux, macOS, and Windows, plus package-contents
+  verification.
+
+_No formatter functionality has shipped yet. See the
+[Roadmap](./docs/ROADMAP.md) for the plan from `0.1` to `1.0`._
+
+[Unreleased]: https://github.com/pkgsort/pkgsort/commits/main

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pkgsort contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,166 @@
+<div align="center">
+
+# pkgsort
+
+**The opinionated, deterministic `package.json` formatter for professional JavaScript & TypeScript teams.**
+
+[![CI](https://github.com/pkgsort/pkgsort/actions/workflows/ci.yml/badge.svg)](https://github.com/pkgsort/pkgsort/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/pkgsort.svg)](https://www.npmjs.com/package/pkgsort)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+[![Node](https://img.shields.io/node/v/pkgsort.svg)](https://nodejs.org)
+
+</div>
+
+> [!NOTE]
+> **Status: pre-release.** The repository foundation is in place; the formatter
+> itself is under active development. See the [Roadmap](./docs/ROADMAP.md).
+
+---
+
+## Why pkgsort?
+
+Every JavaScript project has a `package.json`, and every team eventually argues
+about it: what order should the keys go in? Should `dependencies` be sorted?
+Why does this field have a trailing comma and that one doesn't? Why did the diff
+touch 40 lines when someone ran `npm install`?
+
+[`sort-package-json`](https://github.com/keithamus/sort-package-json) solved
+**key ordering** and did it well. pkgsort is not trying to replace it.
+
+**pkgsort solves a different problem: treating `package.json` as a first-class,
+CI-enforced source artifact.** It reads, sorts, and writes with guarantees a
+casual sorter does not make — byte-level determinism, monorepo-wide
+enforcement, and CI-grade reporting — the way Prettier makes source formatting
+boring and conflict-free.
+
+|                                        | `sort-package-json` | **pkgsort**                                  |
+| -------------------------------------- | ------------------- | -------------------------------------------- |
+| Sort top-level keys                    | ✅                  | ✅                                           |
+| Sort dependency maps                   | ✅                  | ✅                                           |
+| Deterministic, idempotent output       | Partial             | ✅ (guaranteed & tested)                     |
+| `--check` mode for CI                  | ✅                  | ✅ (with actionable diffs)                   |
+| Configurable sort behaviour            | Limited             | ✅ (opinionated defaults, fully overridable) |
+| Monorepo / workspace awareness         | ❌                  | ✅                                           |
+| Structured (JSON) reporter for tooling | ❌                  | ✅                                           |
+
+If all you need is key ordering, `sort-package-json` is a fine, lightweight
+choice. If you manage many packages across many repos and want `package.json`
+to be as boring and diff-free as your Prettier-formatted source, pkgsort is
+built for you.
+
+## Product philosophy
+
+pkgsort is guided by seven principles. Every feature decision is measured
+against them:
+
+1. **Opinionated by default.** Install it, run it, get a good result with zero
+   configuration.
+2. **Configurable when needed.** Every default can be overridden through a
+   documented, validated config file.
+3. **Deterministic.** The same input always produces byte-identical output on
+   every machine, OS, and Node version.
+4. **Safe.** pkgsort never reorders semantically significant data or drops
+   fields it doesn't recognize. Unknown keys are preserved.
+5. **Fast.** Formatting a `package.json` is instant; formatting a 500-package
+   monorepo is measured in milliseconds per file.
+6. **CI friendly.** A first-class `--check` mode, meaningful exit codes, and a
+   machine-readable reporter.
+7. **Great DX.** Clear diffs, clear errors, clear docs.
+
+## Installation
+
+```sh
+# npm
+npm install --save-dev pkgsort
+
+# Yarn
+yarn add --dev pkgsort
+
+# pnpm
+pnpm add -D pkgsort
+
+# Bun
+bun add --dev pkgsort
+```
+
+Or run it once without installing:
+
+```sh
+npx pkgsort --check
+```
+
+> Requires **Node.js 22 LTS** or newer. pkgsort is package-manager agnostic and
+> works the same under npm, Yarn, pnpm, and Bun.
+
+## Usage
+
+### CLI
+
+```sh
+# Format package.json in the current directory (writes in place).
+pkgsort
+
+# Verify formatting without writing — the command CI should run.
+# Exits non-zero if any file would change.
+pkgsort --check
+
+# Format an explicit set of files or globs.
+pkgsort "packages/**/package.json"
+
+# Preview changes without touching disk.
+pkgsort --check --diff
+```
+
+**Exit codes** (stable contract, safe to script against):
+
+| Code | Meaning                                                  |
+| ---- | -------------------------------------------------------- |
+| `0`  | Success — all files already formatted (or were written). |
+| `1`  | In `--check` mode, one or more files are not formatted.  |
+| `2`  | Usage error (bad flags, no files matched).               |
+| `3`  | A file could not be parsed or is invalid.                |
+
+> pkgsort `0.1` ships a **CLI only** — that is the entire public interface. A
+> programmatic/TypeScript API is intentionally not offered yet and may be
+> considered later based on demand (see the [Roadmap](./docs/ROADMAP.md)).
+
+## Configuration
+
+pkgsort works with **zero configuration**. When you need to adjust its
+behaviour, add a `pkgsort.config.json` (JSON), `pkgsort.config.jsonc` (JSON with
+comments), or `pkgsort.config.js` (JavaScript) to your project root — or a
+`"pkgsort"` key in your `package.json`:
+
+```json
+{
+  "indent": 2,
+  "finalNewline": true,
+  "sort": {
+    "dependencies": "alphabetical"
+  }
+}
+```
+
+The complete, documented configuration reference lives in
+[`docs/CONFIG.md`](./docs/CONFIG.md).
+
+## Documentation
+
+| Document                               | Purpose                                   |
+| -------------------------------------- | ----------------------------------------- |
+| [Product Requirements](./docs/PRD.md)  | What we are building and for whom.        |
+| [Architecture](./docs/ARCHITECTURE.md) | How the pipeline is designed.             |
+| [Configuration](./docs/CONFIG.md)      | Every option, its default, and rationale. |
+| [Roadmap](./docs/ROADMAP.md)           | Milestones from `0.x` to `1.0`.           |
+| [Contributing](./CONTRIBUTING.md)      | How to set up, test, and submit changes.  |
+| [Changelog](./CHANGELOG.md)            | Notable changes, per release.             |
+
+## Contributing
+
+We welcome issues and pull requests. Please read the
+[Contributing Guide](./CONTRIBUTING.md) and our
+[Code of Conduct](./CODE_OF_CONDUCT.md) before you start.
+
+## License
+
+[MIT](./LICENSE) © pkgsort contributors

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { ParseError } from './core/parse.js';
+import { formatFile } from './format-file.js';
+/** Exit codes, per `docs/ARCHITECTURE.md` §7. */
+const EXIT_OK = 0;
+const EXIT_USAGE = 2;
+const EXIT_PARSE = 3;
+const HELP_TEXT = `Usage: pkgsort <path-to-package.json>
+
+Sort the top-level keys of a package.json into a canonical order, in place.
+
+Options:
+  -h, --help     Print this help and exit.
+  -v, --version  Print the version number and exit.`;
+/** Read this package's version from its own package.json at runtime. */
+function readVersion() {
+    const pkgPath = fileURLToPath(new URL('../package.json', import.meta.url));
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    return pkg.version;
+}
+/**
+ * The CLI shell: parse argv, format the target file, and translate the outcome
+ * into a process exit code. All formatting logic lives in the pure core; this
+ * layer only handles process concerns.
+ */
+function main(argv) {
+    const arg = argv[2];
+    if (arg === '-h' || arg === '--help') {
+        process.stdout.write(`${HELP_TEXT}\n`);
+        return EXIT_OK;
+    }
+    if (arg === '-v' || arg === '--version') {
+        process.stdout.write(`${readVersion()}\n`);
+        return EXIT_OK;
+    }
+    if (arg === undefined || arg === '') {
+        process.stderr.write(`${HELP_TEXT}\n`);
+        return EXIT_USAGE;
+    }
+    const filePath = arg;
+    try {
+        const { changed } = formatFile(filePath);
+        process.stdout.write(changed ? `Sorted ${filePath}\n` : `${filePath} is already sorted\n`);
+        return EXIT_OK;
+    }
+    catch (error) {
+        if (error instanceof ParseError) {
+            process.stderr.write(`${error.message}\n`);
+            return EXIT_PARSE;
+        }
+        const err = error;
+        if (err.code === 'ENOENT') {
+            process.stderr.write(`File not found: ${filePath}\n`);
+            return EXIT_USAGE;
+        }
+        process.stderr.write(`pkgsort: ${err.message}\n`);
+        return EXIT_USAGE;
+    }
+}
+process.exit(main(process.argv));

package/dist/core/parse.d.ts

@@ -0,0 +1,21 @@
+import type { Style } from '../types.js';
+/**
+ * Thrown when input cannot be parsed as a `package.json` object. The CLI shell
+ * maps this to exit code `3` (see `docs/ARCHITECTURE.md` §7).
+ */
+export declare class ParseError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Parse `input` into a plain object plus its detected whitespace {@link Style}.
+ *
+ * This is the "read" stage of the pipeline: it is pure and never touches the
+ * filesystem. On malformed JSON — or valid JSON that is not a top-level object
+ * — it throws a {@link ParseError}.
+ */
+export declare function parse(input: string): {
+    data: Record<string, unknown>;
+    style: Style;
+};

package/dist/core/parse.js

@@ -0,0 +1,47 @@
+/**
+ * Thrown when input cannot be parsed as a `package.json` object. The CLI shell
+ * maps this to exit code `3` (see `docs/ARCHITECTURE.md` §7).
+ */
+export class ParseError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'ParseError';
+    }
+}
+/**
+ * Parse `input` into a plain object plus its detected whitespace {@link Style}.
+ *
+ * This is the "read" stage of the pipeline: it is pure and never touches the
+ * filesystem. On malformed JSON — or valid JSON that is not a top-level object
+ * — it throws a {@link ParseError}.
+ */
+export function parse(input) {
+    let data;
+    try {
+        data = JSON.parse(input);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new ParseError(`Invalid JSON: ${detail}`, { cause: error });
+    }
+    if (data === null || typeof data !== 'object' || Array.isArray(data)) {
+        throw new ParseError('Expected a JSON object at the top level of package.json');
+    }
+    return {
+        data: data,
+        style: {
+            indent: detectIndent(input),
+            trailingNewline: input.endsWith('\n'),
+        },
+    };
+}
+/**
+ * Detect the indentation of one level from the raw text by inspecting the
+ * leading whitespace of the first indented line. Falls back to two spaces —
+ * the ecosystem default — when the document has no indented lines (e.g. it is
+ * written on a single line).
+ */
+function detectIndent(input) {
+    const match = /\r?\n([ \t]+)\S/.exec(input);
+    return match?.[1] ?? '  ';
+}

package/dist/core/pipeline.d.ts

@@ -0,0 +1,9 @@
+import type { FormatResult } from '../types.js';
+/**
+ * The pure formatting pipeline: **parse → sort → serialize**.
+ *
+ * Given the text of a `package.json`, return the formatted text and whether it
+ * differs from the input. Throws {@link ParseError} on invalid input. This
+ * function performs no I/O and is fully deterministic.
+ */
+export declare function format(input: string): FormatResult;

package/dist/core/pipeline.js

@@ -0,0 +1,16 @@
+import { sortTopLevelKeys } from '../sorters/top-level-keys.js';
+import { parse } from './parse.js';
+import { serialize } from './serialize.js';
+/**
+ * The pure formatting pipeline: **parse → sort → serialize**.
+ *
+ * Given the text of a `package.json`, return the formatted text and whether it
+ * differs from the input. Throws {@link ParseError} on invalid input. This
+ * function performs no I/O and is fully deterministic.
+ */
+export function format(input) {
+    const { data, style } = parse(input);
+    const sorted = sortTopLevelKeys(data);
+    const output = serialize(sorted, style);
+    return { output, changed: output !== input };
+}

package/dist/core/serialize.d.ts

@@ -0,0 +1,9 @@
+import type { Style } from '../types.js';
+/**
+ * Serialize `data` to JSON text using the given whitespace {@link Style}.
+ *
+ * This is the "write" stage and the *only* place whitespace decisions are made,
+ * so output is a pure function of the object plus its style. Line endings are
+ * always `\n`; the trailing newline is reproduced from the detected style.
+ */
+export declare function serialize(data: Record<string, unknown>, style: Style): string;

package/dist/core/serialize.js

@@ -0,0 +1,11 @@
+/**
+ * Serialize `data` to JSON text using the given whitespace {@link Style}.
+ *
+ * This is the "write" stage and the *only* place whitespace decisions are made,
+ * so output is a pure function of the object plus its style. Line endings are
+ * always `\n`; the trailing newline is reproduced from the detected style.
+ */
+export function serialize(data, style) {
+    const json = JSON.stringify(data, null, style.indent);
+    return style.trailingNewline ? `${json}\n` : json;
+}

package/dist/format-file.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Read a `package.json` from disk, format it, and write it back in place when
+ * it changed.
+ *
+ * This is the thin effectful shell around the pure {@link format} core: it owns
+ * the file I/O so the core stays deterministic and testable. Errors from
+ * reading (e.g. a missing file) and parsing ({@link ParseError}) propagate to
+ * the caller, which maps them to exit codes.
+ */
+export declare function formatFile(filePath: string): {
+    changed: boolean;
+};

package/dist/format-file.js

@@ -0,0 +1,19 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { format } from './core/pipeline.js';
+/**
+ * Read a `package.json` from disk, format it, and write it back in place when
+ * it changed.
+ *
+ * This is the thin effectful shell around the pure {@link format} core: it owns
+ * the file I/O so the core stays deterministic and testable. Errors from
+ * reading (e.g. a missing file) and parsing ({@link ParseError}) propagate to
+ * the caller, which maps them to exit codes.
+ */
+export function formatFile(filePath) {
+    const input = readFileSync(filePath, 'utf8');
+    const { output, changed } = format(input);
+    if (changed) {
+        writeFileSync(filePath, output, 'utf8');
+    }
+    return { changed };
+}

package/dist/sorters/top-level-keys.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The canonical order for top-level `package.json` keys.
+ *
+ * This list mirrors the default field order of the widely-used
+ * [`sort-package-json`](https://github.com/keithamus/sort-package-json) project
+ * (as of 2026-07-04), so pkgsort produces the ordering the ecosystem already
+ * expects. Keys are grouped by purpose: identity, descriptive metadata, module
+ * type & entry points, files, scripts & tool config, dependency maps,
+ * environment constraints, and publishing.
+ *
+ * **Intentional divergence:** pkgsort deliberately does *not* copy
+ * `sort-package-json`'s handling of keys that are absent from this list.
+ * `sort-package-json` sorts unknown keys alphabetically; pkgsort preserves
+ * their original relative order and appends them after all known keys (see
+ * {@link sortTopLevelKeys} and `docs/CONFIG.md` §3.2, `unknownKeys: "end"`).
+ */
+export declare const DEFAULT_KEY_ORDER: readonly string[];
+/**
+ * Return a new object with the same entries as `data`, its top-level keys
+ * reordered into {@link DEFAULT_KEY_ORDER}.
+ *
+ * Only the arrangement of top-level keys changes: values (including nested
+ * objects) are carried over untouched, and unknown keys keep their original
+ * relative order at the end. The comparison is purely index-based, so the
+ * result is deterministic and independent of locale.
+ */
+export declare function sortTopLevelKeys(data: Record<string, unknown>): Record<string, unknown>;

package/dist/sorters/top-level-keys.js

@@ -0,0 +1,157 @@
+/**
+ * The canonical order for top-level `package.json` keys.
+ *
+ * This list mirrors the default field order of the widely-used
+ * [`sort-package-json`](https://github.com/keithamus/sort-package-json) project
+ * (as of 2026-07-04), so pkgsort produces the ordering the ecosystem already
+ * expects. Keys are grouped by purpose: identity, descriptive metadata, module
+ * type & entry points, files, scripts & tool config, dependency maps,
+ * environment constraints, and publishing.
+ *
+ * **Intentional divergence:** pkgsort deliberately does *not* copy
+ * `sort-package-json`'s handling of keys that are absent from this list.
+ * `sort-package-json` sorts unknown keys alphabetically; pkgsort preserves
+ * their original relative order and appends them after all known keys (see
+ * {@link sortTopLevelKeys} and `docs/CONFIG.md` §3.2, `unknownKeys: "end"`).
+ */
+export const DEFAULT_KEY_ORDER = [
+    // Identity
+    '$schema',
+    'name',
+    'displayName',
+    'version',
+    'stableVersion',
+    'private',
+    // Descriptive metadata
+    'description',
+    'categories',
+    'keywords',
+    'homepage',
+    'bugs',
+    'repository',
+    'funding',
+    'license',
+    'qna',
+    'author',
+    'maintainers',
+    'contributors',
+    'publisher',
+    // Module type & entry points
+    'sideEffects',
+    'type',
+    'imports',
+    'exports',
+    'main',
+    'svelte',
+    'umd:main',
+    'jsdelivr',
+    'unpkg',
+    'module',
+    'source',
+    'jsnext:main',
+    'browser',
+    'react-native',
+    'types',
+    'typesVersions',
+    'typings',
+    'style',
+    'example',
+    'examplestyle',
+    'assets',
+    'bin',
+    'man',
+    'directories',
+    'files',
+    'workspaces',
+    'binary',
+    // Scripts & tool configuration
+    'scripts',
+    'betterScripts',
+    'wireit',
+    'l10n',
+    'contributes',
+    'activationEvents',
+    'husky',
+    'simple-git-hooks',
+    'pre-commit',
+    'commitlint',
+    'lint-staged',
+    'nano-staged',
+    'config',
+    'nodemonConfig',
+    'browserify',
+    'babel',
+    'browserslist',
+    'xo',
+    'prettier',
+    'eslintConfig',
+    'eslintIgnore',
+    'npmpkgjsonlint',
+    'npmPackageJsonLintConfig',
+    'npmpackagejsonlint',
+    'release',
+    'remarkConfig',
+    'stylelint',
+    'ava',
+    'jest',
+    'jest-junit',
+    'jest-stare',
+    'mocha',
+    'nyc',
+    'c8',
+    'tap',
+    'oclif',
+    // Dependency maps
+    'resolutions',
+    'overrides',
+    'dependencies',
+    'devDependencies',
+    'dependenciesMeta',
+    'peerDependencies',
+    'peerDependenciesMeta',
+    'optionalDependencies',
+    'bundledDependencies',
+    'bundleDependencies',
+    'extensionPack',
+    'extensionDependencies',
+    'flat',
+    // Environment constraints
+    'packageManager',
+    'engines',
+    'engineStrict',
+    'devEngines',
+    'volta',
+    'languageName',
+    'os',
+    'cpu',
+    'preferGlobal',
+    // Publishing & presentation
+    'publishConfig',
+    'icon',
+    'badges',
+    'galleryBanner',
+    'preview',
+    'markdown',
+    'pnpm',
+];
+const KEY_RANK = new Map(DEFAULT_KEY_ORDER.map((key, index) => [key, index]));
+/**
+ * Return a new object with the same entries as `data`, its top-level keys
+ * reordered into {@link DEFAULT_KEY_ORDER}.
+ *
+ * Only the arrangement of top-level keys changes: values (including nested
+ * objects) are carried over untouched, and unknown keys keep their original
+ * relative order at the end. The comparison is purely index-based, so the
+ * result is deterministic and independent of locale.
+ */
+export function sortTopLevelKeys(data) {
+    const rank = (key) => KEY_RANK.get(key) ?? Number.MAX_SAFE_INTEGER;
+    // Array.prototype.sort is stable, so two unknown keys (equal rank) retain
+    // their original order.
+    const orderedKeys = Object.keys(data).sort((a, b) => rank(a) - rank(b));
+    const result = {};
+    for (const key of orderedKeys) {
+        result[key] = data[key];
+    }
+    return result;
+}

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared internal types.
+ *
+ * These describe the data that flows through the pure core; they are not a
+ * published, stable API (see `docs/ARCHITECTURE.md` §8).
+ */
+/**
+ * The whitespace style detected from — and re-applied to — a `package.json`.
+ * We record the original detail so the serializer can reproduce it and so we
+ * can report `changed` accurately.
+ */
+export interface Style {
+    /** The literal indentation of one level, e.g. `"  "`, `"    "`, or `"\t"`. */
+    indent: string;
+    /** Whether the original file ended with a trailing newline. */
+    trailingNewline: boolean;
+}
+/** The result of formatting a single `package.json` document. */
+export interface FormatResult {
+    /** The formatted text. */
+    output: string;
+    /** `true` when {@link FormatResult.output} differs from the input. */
+    changed: boolean;
+}

package/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * Shared internal types.
+ *
+ * These describe the data that flows through the pure core; they are not a
+ * published, stable API (see `docs/ARCHITECTURE.md` §8).
+ */
+export {};

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@rsuvarna/pkgsort",
+  "version": "0.1.0",
+  "description": "The opinionated, deterministic package.json formatter for professional JavaScript and TypeScript teams.",
+  "keywords": [
+    "package.json",
+    "formatter",
+    "linter",
+    "sort",
+    "monorepo",
+    "workspaces",
+    "prettier",
+    "eslint",
+    "ci",
+    "deterministic"
+  ],
+  "homepage": "https://github.com/rahulsuvarna/pkgsort#readme",
+  "bugs": {
+    "url": "https://github.com/rahulsuvarna/pkgsort/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rahulsuvarna/pkgsort.git"
+  },
+  "license": "MIT",
+  "author": "pkgsort contributors",
+  "type": "module",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  },
+  "sideEffects": false,
+  "bin": {
+    "pkgsort": "./dist/cli.js"
+  },
+  "exports": {
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "dev": "tsc --project tsconfig.build.json --watch",
+    "clean": "rimraf dist coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "check": "npm run typecheck && npm run lint && npm run format:check && npm run test",
+    "prepublishOnly": "npm run clean && npm run check && npm run build",
+    "changeset": "changeset",
+    "release": "changeset publish"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^22.20.0",
+    "@vitest/coverage-v8": "^4.1.9",
+    "eslint": "^10.6.0",
+    "eslint-config-prettier": "^10.1.8",
+    "prettier": "^3.9.4",
+    "rimraf": "^6.1.3",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.62.1",
+    "vitest": "^4.1.9"
+  }
+}