json5-manifest-sync 0.1.3

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+## [0.1.2] - 2026-02-25
+
+### Fixed
+
+- Fixed CLI entrypoint detection so execution works through npm/yarn/pnpm `.bin` symlinks and wrappers.
+- Fixed `npm run sync:json5` no-op behavior seen in consuming repositories installed from git dependencies.
+- Kept direct invocation behavior intact for `node dist/json5-manifest-sync.js`.
+
+### Tests
+
+- Added coverage for direct invocation path detection.
+- Added coverage for symlinked `.bin`-style invocation path detection.
+- Added regression test proving `runCli` updates `package.json5` from canonical `package.json`.

package/README.md

@@ -0,0 +1,141 @@
+# json5-manifest-sync
+
+Keep a documented `package.json5` in sync with the real `package.json` used by Node and package managers.
+
+## Quick Start
+
+```bash
+npm install github:BBaysinger/json5-manifest-sync#v0.1.3
+```
+
+Add a script in your project's `package.json`:
+
+```json
+{
+  "scripts": {
+    "sync:json5": "json5-manifest-sync"
+  }
+}
+```
+
+Run it:
+
+```bash
+npm run sync:json5
+```
+
+## Why this exists
+
+`package.json` must be strict JSON, which means comments are invalid. That makes it hard to document complex scripts, dependency choices, or workspace settings directly in the manifest.
+
+`package.json` is arguably the most important file in most JavaScript/TypeScript repositories. It drives install behavior, scripts, dependency policy, packaging, and release workflows—so it deserves clear inline documentation.
+
+At the same time, Node/npm/pnpm/yarn do not treat `package.json5` as a package manifest source. A JSON5 file can be great for human-readable documentation, but tooling still requires `package.json`.
+
+> [!NOTE]
+> It would be great to see first-class support for JSON5-style manifests in npm/tooling over time, but today this project provides a practical bridge.
+
+This tool solves that gap by letting you maintain both:
+
+- `package.json` as the canonical, machine-consumed manifest
+- `package.json5` as the human-documented companion file
+
+Then it synchronizes `package.json5` from `package.json` while preserving mapped `//` comments where possible.
+
+## What it does
+
+- Finds `package.json` files recursively (excluding `node_modules`)
+- Skips paths ignored by your root `.gitignore`
+- For each matching `package.json5`, rewrites values from canonical `package.json`
+- Preserves/migrates mapped `//` comments for keys and supported array items
+- Writes stable JSON5 formatting with trailing commas for cleaner diffs
+
+Repository: https://github.com/BBaysinger/json5-manifest-sync
+
+## Author
+
+Bradley Baysinger ([@BBaysinger](https://github.com/BBaysinger))
+
+## Install from GitHub
+
+Install from a tag (recommended):
+
+```bash
+npm install github:BBaysinger/json5-manifest-sync#v0.1.3
+```
+
+Or from a branch during iteration:
+
+```bash
+npm install github:BBaysinger/json5-manifest-sync#main
+```
+
+Because this repo defines a `prepare` script, npm will build TypeScript during git-based install.
+
+## Use in a project
+
+Add a script in your consuming project's `package.json`:
+
+```json
+{
+  "scripts": {
+    "sync:json5": "json5-manifest-sync"
+  }
+}
+```
+
+Run it:
+
+```bash
+npm run sync:json5
+```
+
+## Generated `package.json5` example
+
+Illustrative output (trimmed):
+
+<!-- prettier-ignore -->
+```json5
+{
+  // Package name used by npm and consumers.
+  "name": "consumer-app",
+  // Release version (keep in sync with git tags).
+  "version": "1.2.3",
+  // Development and release scripts.
+  "scripts": {
+    // Compile TypeScript to dist/.
+    "build": "tsc -p tsconfig.json",
+  },
+}
+```
+
+For the current full output style, see this repo's live example: [`package.json5`](./package.json5).
+
+### Options
+
+- `--no-empty-comment` or `--no-empty-comments`
+- `--empty-comment=false`
+- env var: `SYNC_JSON5_ADD_EMPTY_COMMENT=false`
+
+### Formatting note
+
+Recommended: exclude `package.json5` from Prettier (for example via `.prettierignore`).
+
+Prettier's JSON5 formatter can remove quotes from valid keys, which makes `package.json5` less similar to canonical `package.json`. Ignoring `package.json5` helps preserve intentional key/comment style and reduces avoidable drift.
+
+> [!NOTE]
+> It would be nice if Prettier provided an option to preserve quoted keys in JSON5.
+
+## Example dependency block in consumer
+
+```json
+{
+  "dependencies": {
+    "json5-manifest-sync": "github:BBaysinger/json5-manifest-sync#v0.1.3"
+  }
+}
+```
+
+## Changelog
+
+See `CHANGELOG.md` for full release history.

package/dist/json5-manifest-sync.d.ts

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+/**
+ * JSON5 Package Synchronization Tool
+ *
+ * Synchronizes package.json5 files with their canonical package.json counterparts.
+ *
+ * Source of truth: package.json (parsed as strict JSON).
+ * Output: package.json5 rewritten with stable formatting and with *some* `//` comments
+ * preserved/migrated onto the corresponding keys/items.
+ *
+ * Important: this script does NOT attempt to preserve arbitrary formatting (blank
+ * lines, exact indentation, key ordering, etc.). It regenerates the JSON5 structure
+ * using a consistent 2-space indent and trailing commas.
+ *
+ * This tool handles:
+ * - Preceding `//` comments immediately above object keys
+ * - Trailing `//` comments on the same line as a key/value
+ * - Nested objects/arrays via simple brace/bracket tracking
+ * - Arrays: preserves comments for string-literal items when each item is on its own line
+ * - Always emits trailing commas for cleaner diffs
+ *
+ * Limitations (by design / current implementation):
+ * - Only line comments (`//`) are recognized. Block comments (`/* ... *\/`) are ignored.
+ * - Trailing-comment detection is heuristic (quote counting) and is most reliable for
+ *   double-quoted strings; unusual quoting/escaping can confuse it.
+ * - Array item comment mapping is primarily intended for arrays of strings; arrays of
+ *   objects/numbers will serialize correctly but per-item comment preservation is limited.
+ */
+export type SyncOptions = {
+    /**
+     * When true, insert a blank comment line (`//`) before any key that has no
+     * preceding comment captured from the existing JSON5. This helps visually
+     * separate entries like:
+     *
+     *   "private": true,
+     *   //
+     *   "type": "module",
+     *
+     * Defaults to true. Can be disabled via CLI flag `--no-empty-comment` or the
+     * environment variable `SYNC_JSON5_ADD_EMPTY_COMMENT=false`.
+     */
+    addEmptyCommentIfMissing?: boolean;
+};
+/**
+ * Synchronizes a JSON5 file with its canonical JSON source while preserving formatting.
+ *
+ * This is the main synchronization function that:
+ * - Parses the existing JSON5 to extract comments and structure
+ * - Applies the canonical JSON data as the source of truth
+ * - Reconstructs the JSON5 with preserved comments and consistent formatting
+ * - Uses trailing commas throughout for version control benefits
+ *
+ * The process ensures that while the data stays synchronized with the canonical
+ * source, all the valuable documentation and formatting is maintained.
+ *
+ * @param raw - Raw contents of the existing JSON5 file
+ * @param source - Parsed JSON object from the canonical package.json
+ * @returns The updated JSON5 content as a formatted string
+ */
+export declare function syncJson5(raw: string, source: Record<string, unknown>, options?: SyncOptions): string;
+/**
+ * CLI entrypoint.
+ *
+ * Scans from the current working directory and synchronizes any
+ * `package.json5` files that have a sibling `package.json`.
+ *
+ * @param args - Optional CLI arguments (defaults to process argv slice)
+ */
+export declare function runCli(args?: string[]): void;
+/**
+ * Determines whether this module is being executed as a CLI entrypoint.
+ *
+ * This supports direct Node execution and npm/pnpm/yarn .bin symlink paths by
+ * comparing normalized real paths when possible.
+ *
+ * @param argv1 - Entry script path (typically process.argv[1])
+ * @param moduleUrl - URL of this module (typically import.meta.url)
+ * @returns true when current process should run CLI behavior
+ */
+export declare function isCliInvocation(argv1?: string | undefined, moduleUrl?: string): boolean;

package/dist/json5-manifest-sync.js

@@ -0,0 +1,399 @@
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { sync as globSync } from "glob";
+import ignore from "ignore";
+/**
+ * Quotes an object key for consistent JSON5 formatting.
+ * Always returns a quoted key to maintain consistency across all properties.
+ *
+ * @param key - The key to quote
+ * @returns The quoted key string (e.g., "scripts", "dependencies")
+ */
+function quoteKey(key) {
+    return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? `"${key}"` : JSON.stringify(key);
+}
+/**
+ * Indents a line by the specified number of spaces and trims surrounding whitespace.
+ * Used to maintain consistent indentation throughout the generated JSON5.
+ *
+ * @param line - The line to indent
+ * @param level - The number of spaces to indent (default: 0)
+ * @returns The properly indented line
+ */
+function indent(line, level = 0) {
+    return " ".repeat(level) + line.trim();
+}
+/**
+ * Parses a JSON5 file and builds a comment map with path-based indexing.
+ *
+ * This is the core parsing function that:
+ * - Tracks nested object/array structure using path stacks
+ * - Maps comments to their associated JSON paths (e.g., "pnpm.onlyBuiltDependencies.0")
+ * - Handles both preceding comments (above lines) and trailing comments (same line)
+ * - Heuristically detects comments vs URLs containing "//" sequences
+ * - Supports array items with individual comments and numeric indices
+ *
+ * The comment map structure allows for precise reconstruction of the original
+ * formatting while applying new data from the canonical source.
+ *
+ * @param lines - Lines from the existing JSON5 file
+ * @returns A map of dot-notation paths to comment information
+ */
+function buildCommentMap(lines) {
+    const commentsMap = {};
+    // State tracking for nested structure parsing.
+    const pathStack = [];
+    const arrayIndexStack = [];
+    let bufferedComments = [];
+    let insideArray = false;
+    /**
+     * Extracts trailing comments from a line while correctly handling URLs.
+     *
+     * This function attempts to distinguish actual comments vs "//" sequences that
+     * appear inside string values (like URLs) using a lightweight heuristic.
+     *
+     * Notes:
+     * - It is designed for typical package.json(5) formatting (double-quoted strings).
+     * - It does not implement full JSON5 tokenization; unusual quoting/escaping may
+     *   lead to false positives/negatives.
+     *
+     * Examples:
+     * - `"url": "https://github.com/user/repo", // This is a comment` ✅
+     * - `"url": "https://github.com/user/repo"` (no comment) ✅
+     *
+     * @param line - The line to analyze for trailing comments
+     * @returns The trailing comment string (including "//") or undefined
+     */
+    function extractTrailingComment(line) {
+        let searchStart = 0;
+        while (true) {
+            const commentIdx = line.indexOf("//", searchStart);
+            if (commentIdx === -1)
+                return undefined;
+            // Count quotes before this "//" to determine if we're inside a string
+            const beforeComment = line.slice(0, commentIdx);
+            const quoteCount = (beforeComment.match(/"/g) || []).length;
+            // Even number of quotes = outside string = actual comment
+            if (quoteCount % 2 === 0) {
+                return line.slice(commentIdx).trim();
+            }
+            // Odd number = inside string (like URL), keep searching
+            searchStart = commentIdx + 2;
+        }
+    }
+    // Process each line and associate comments with object/array paths.
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Skip empty lines
+        if (!trimmed)
+            continue;
+        // Collect preceding comments (lines that start with //)
+        if (trimmed.startsWith("//")) {
+            bufferedComments.push(line);
+            continue;
+        }
+        // Handle array start patterns: "key": [
+        const arrayStartMatch = line.match(/^\s*(["']?)([^"']+)\1\s*:\s*\[\s*$/);
+        if (arrayStartMatch) {
+            const key = arrayStartMatch[2];
+            const fullPath = [...pathStack, key].join(".");
+            const commentInfo = {
+                preceding: [...bufferedComments],
+            };
+            const trailing = extractTrailingComment(line);
+            if (trailing) {
+                commentInfo.trailing = trailing;
+            }
+            if (commentInfo.preceding.length > 0 || commentInfo.trailing) {
+                commentsMap[fullPath] = commentInfo;
+            }
+            pathStack.push(key);
+            arrayIndexStack.push(0);
+            insideArray = true;
+            bufferedComments = [];
+            continue;
+        }
+        // Handle array items - lines that start with quotes but contain no colon
+        if (insideArray && trimmed.startsWith('"') && !trimmed.includes(":")) {
+            const currentArrayIndex = arrayIndexStack[arrayIndexStack.length - 1];
+            const arrayItemPath = [...pathStack, currentArrayIndex.toString()].join(".");
+            const commentInfo = {
+                preceding: [...bufferedComments],
+            };
+            const trailing = extractTrailingComment(line);
+            if (trailing) {
+                commentInfo.trailing = trailing;
+            }
+            if (commentInfo.preceding.length > 0 || commentInfo.trailing) {
+                commentsMap[arrayItemPath] = commentInfo;
+            }
+            // Increment array index for next item and clear comment buffer
+            arrayIndexStack[arrayIndexStack.length - 1]++;
+            bufferedComments = [];
+            continue;
+        }
+        // Handle regular object keys.
+        const keyMatch = line.match(/^\s*(["']?)([^"']+)\1\s*:/);
+        if (keyMatch) {
+            const key = keyMatch[2];
+            const fullPath = [...pathStack, key].join(".");
+            const commentInfo = {
+                preceding: [...bufferedComments],
+            };
+            const trailing = extractTrailingComment(line);
+            if (trailing) {
+                commentInfo.trailing = trailing;
+            }
+            if (commentInfo.preceding.length > 0 || commentInfo.trailing) {
+                commentsMap[fullPath] = commentInfo;
+            }
+            bufferedComments = [];
+            // If this is an object start, update the path stack
+            if (trimmed.endsWith("{")) {
+                pathStack.push(key);
+                insideArray = false;
+            }
+        }
+        else if (bufferedComments.length > 0 && trimmed !== "") {
+            // Non-comment, non-key lines break the comment block
+            bufferedComments = [];
+        }
+        // Handle closing brackets to maintain proper nesting.
+        if (trimmed === "}" ||
+            trimmed === "}," ||
+            trimmed === "]" ||
+            trimmed === "],") {
+            if (trimmed.startsWith("]")) {
+                insideArray = false;
+                if (arrayIndexStack.length > 0) {
+                    arrayIndexStack.pop();
+                }
+            }
+            if (pathStack.length)
+                pathStack.pop();
+        }
+    }
+    return commentsMap;
+}
+/**
+ * Generates a simple blank comment used as a visual spacer when enabled.
+ *
+ * @returns A blank comment string
+ */
+function generateScriptComment() {
+    return "//";
+}
+/**
+ * Synchronizes a JSON5 file with its canonical JSON source while preserving formatting.
+ *
+ * This is the main synchronization function that:
+ * - Parses the existing JSON5 to extract comments and structure
+ * - Applies the canonical JSON data as the source of truth
+ * - Reconstructs the JSON5 with preserved comments and consistent formatting
+ * - Uses trailing commas throughout for version control benefits
+ *
+ * The process ensures that while the data stays synchronized with the canonical
+ * source, all the valuable documentation and formatting is maintained.
+ *
+ * @param raw - Raw contents of the existing JSON5 file
+ * @param source - Parsed JSON object from the canonical package.json
+ * @returns The updated JSON5 content as a formatted string
+ */
+export function syncJson5(raw, source, options = { addEmptyCommentIfMissing: true }) {
+    const lines = raw.split("\n");
+    const comments = buildCommentMap(lines);
+    const addEmptyCommentIfMissing = options.addEmptyCommentIfMissing !== undefined
+        ? options.addEmptyCommentIfMissing
+        : true;
+    /**
+     * Recursively writes an object in normalized JSON5 style with mapped comments.
+     *
+     * @param obj - Object subtree from canonical JSON
+     * @param path - Dot-notation path for comment lookups
+     * @param level - Current indentation level in spaces
+     * @returns Formatted output lines for this subtree
+     */
+    function writeObject(obj, path = [], level = 2) {
+        const result = [];
+        // Type guard to ensure obj is an object
+        if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+            return result;
+        }
+        const keys = Object.keys(obj);
+        const indentSize = 2;
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const fullPath = [...path, key].join(".");
+            const val = obj[key];
+            const comma = ","; // Always add trailing comma for version control benefits
+            const commentInfo = comments[fullPath];
+            // Add any preceding comments above this key
+            if (commentInfo?.preceding && commentInfo.preceding.length > 0) {
+                for (const c of commentInfo.preceding) {
+                    result.push(indent(c, level));
+                }
+            }
+            else if (addEmptyCommentIfMissing &&
+                !comments.hasOwnProperty(fullPath)) {
+                // No preceding comment captured — optionally add a blank one for spacing
+                // Applies to any section, not just scripts
+                const autoComment = generateScriptComment();
+                result.push(indent(autoComment, level));
+            }
+            if (typeof val === "object" && val !== null && !Array.isArray(val)) {
+                // Handle nested objects with optional trailing comment on opening brace
+                const openLine = `${quoteKey(key)}: {`;
+                const withTrailing = commentInfo?.trailing
+                    ? `${openLine} ${commentInfo.trailing}`
+                    : openLine;
+                result.push(indent(withTrailing, level));
+                // Recursively process nested object
+                result.push(...writeObject(val, [...path, key], level + indentSize));
+                result.push(indent(`}${comma}`, level));
+            }
+            else if (Array.isArray(val)) {
+                // Handle arrays with optional trailing comment on opening bracket
+                const openLine = `${quoteKey(key)}: [`;
+                const withTrailing = commentInfo?.trailing
+                    ? `${openLine} ${commentInfo.trailing}`
+                    : openLine;
+                result.push(indent(withTrailing, level));
+                // Process each array item with individual comments
+                for (let j = 0; j < val.length; j++) {
+                    const itemPath = [...path, key, j.toString()].join(".");
+                    const itemCommentInfo = comments[itemPath];
+                    // Add preceding comments for this array item
+                    if (itemCommentInfo?.preceding) {
+                        for (const c of itemCommentInfo.preceding) {
+                            result.push(indent(c, level + indentSize));
+                        }
+                    }
+                    else if (addEmptyCommentIfMissing &&
+                        !comments.hasOwnProperty(itemPath)) {
+                        const autoComment = generateScriptComment();
+                        result.push(indent(autoComment, level + indentSize));
+                    }
+                    // Add array item with optional trailing comment
+                    const itemLine = `${JSON.stringify(val[j])},`;
+                    const withTrailing = itemCommentInfo?.trailing
+                        ? `${itemLine} ${itemCommentInfo.trailing}`
+                        : itemLine;
+                    result.push(indent(withTrailing, level + indentSize));
+                }
+                result.push(indent(`]${comma}`, level));
+            }
+            else {
+                // Handle primitive values (strings, numbers, booleans) with optional trailing comment
+                const valueLine = `${quoteKey(key)}: ${JSON.stringify(val)}${comma}`;
+                const withTrailing = commentInfo?.trailing
+                    ? `${valueLine} ${commentInfo.trailing}`
+                    : valueLine;
+                result.push(indent(withTrailing, level));
+            }
+        }
+        return result;
+    }
+    // Generate the complete JSON5 structure
+    const generated = writeObject(source, [], 2);
+    return `{\n${generated.join("\n")}\n}`;
+}
+// 🔁 Main Execution Runner
+//
+// This section handles the file discovery and processing logic:
+// - Finds all package.json files in the project (excluding node_modules)
+// - Checks for corresponding package.json5 files
+// - Applies root .gitignore rules to skip excluded files
+// - Performs synchronization for each valid pair
+/**
+ * CLI entrypoint.
+ *
+ * Scans from the current working directory and synchronizes any
+ * `package.json5` files that have a sibling `package.json`.
+ *
+ * @param args - Optional CLI arguments (defaults to process argv slice)
+ */
+export function runCli(args = process.argv.slice(2)) {
+    const rootDir = process.cwd();
+    const ig = ignore();
+    const gitignorePath = path.join(rootDir, ".gitignore");
+    // Load gitignore rules if available
+    if (fs.existsSync(gitignorePath)) {
+        ig.add(fs.readFileSync(gitignorePath, "utf8"));
+    }
+    // Find all package.json files recursively, excluding node_modules
+    const packageJsonPaths = globSync("**/package.json", {
+        cwd: rootDir,
+        ignore: ["**/node_modules/**"],
+        absolute: true,
+    });
+    // Parse simple CLI flags / env for options
+    let addEmptyCommentIfMissing = true;
+    // Env toggle: SYNC_JSON5_ADD_EMPTY_COMMENT=false
+    if (typeof process.env.SYNC_JSON5_ADD_EMPTY_COMMENT === "string" &&
+        process.env.SYNC_JSON5_ADD_EMPTY_COMMENT.toLowerCase() === "false") {
+        addEmptyCommentIfMissing = false;
+    }
+    // CLI toggles: --no-empty-comment, --empty-comment=false
+    for (const arg of args) {
+        if (arg === "--no-empty-comment" || arg === "--no-empty-comments") {
+            addEmptyCommentIfMissing = false;
+        }
+        else if (arg.startsWith("--empty-comment=")) {
+            const v = arg.split("=", 2)[1]?.toLowerCase();
+            if (v === "false" || v === "0" || v === "no") {
+                addEmptyCommentIfMissing = false;
+            }
+        }
+    }
+    // Process each package.json to sync with its package.json5 counterpart
+    for (const packageJsonPath of packageJsonPaths) {
+        const relPath = path.relative(rootDir, packageJsonPath);
+        // Skip files that match gitignore patterns
+        if (ig.ignores(relPath))
+            continue;
+        const json5Path = packageJsonPath + "5"; // package.json5
+        // Skip if no corresponding package.json5 exists
+        if (!fs.existsSync(json5Path)) {
+            console.info(`⏩ Skipping ${relPath} — no package.json5 found`);
+            continue;
+        }
+        // Perform the synchronization
+        const rawJson5 = fs.readFileSync(json5Path, "utf8");
+        const sourceJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+        const updated = syncJson5(rawJson5, sourceJson, {
+            addEmptyCommentIfMissing,
+        });
+        // Write the synchronized result
+        fs.writeFileSync(json5Path, updated);
+        console.info(`✅ Synced ${relPath} → ${path.basename(json5Path)}`);
+    }
+}
+/**
+ * Determines whether this module is being executed as a CLI entrypoint.
+ *
+ * This supports direct Node execution and npm/pnpm/yarn .bin symlink paths by
+ * comparing normalized real paths when possible.
+ *
+ * @param argv1 - Entry script path (typically process.argv[1])
+ * @param moduleUrl - URL of this module (typically import.meta.url)
+ * @returns true when current process should run CLI behavior
+ */
+export function isCliInvocation(argv1 = process.argv[1], moduleUrl = import.meta.url) {
+    if (!argv1)
+        return false;
+    const modulePath = fileURLToPath(moduleUrl);
+    const entryPath = path.resolve(argv1);
+    try {
+        return fs.realpathSync(entryPath) === fs.realpathSync(modulePath);
+    }
+    catch {
+        // Fall back to normalized absolute-path comparison if realpath fails.
+        return path.resolve(entryPath) === path.resolve(modulePath);
+    }
+}
+if (isCliInvocation()) {
+    runCli();
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "json5-manifest-sync",
+  "version": "0.1.3",
+  "description": "Sync package.json5 files from canonical package.json while preserving key comments.",
+  "author": {
+    "name": "Bradley Baysinger",
+    "url": "https://github.com/BBaysinger"
+  },
+  "type": "module",
+  "main": "./dist/json5-manifest-sync.js",
+  "types": "./dist/json5-manifest-sync.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/json5-manifest-sync.d.ts",
+      "default": "./dist/json5-manifest-sync.js"
+    }
+  },
+  "bin": {
+    "json5-manifest-sync": "./dist/json5-manifest-sync.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "format": "prettier . --write",
+    "format:check": "prettier . --check",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepare": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "glob": "^11.0.1",
+    "ignore": "^7.0.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "prettier": "^3.8.1",
+    "typescript": "^5.8.2",
+    "vitest": "^2.1.9"
+  }
+}