screw-up 0.9.1 → 0.11.0

package/dist/cli.js

@@ -1,83 +1,377 @@
 #!/usr/bin/env node
 import { resolve, join } from "path";
-import { existsSync, createWriteStream, createReadStream } from "fs";
-import { lstat, mkdir, mkdtemp, rm, stat } from "fs/promises";
+import { createWriteStream, createReadStream, existsSync } from "fs";
+import { stat, mkdir, lstat, mkdtemp, rm } from "fs/promises";
 import { spawn } from "child_process";
 import { glob } from "glob";
-import { a as resolveRawPackageJson } from "./internal-JwF_Mrdt.js";
-import tar from "tar-stream";
-import zlib from "zlib";
-const addPackContentEntry = async (pack, name, content) => {
-  pack.entry({
-    name,
-    type: "file",
-    mode: 420,
-    mtime: /* @__PURE__ */ new Date(),
-    size: Buffer.byteLength(content, "utf8")
-  }, content);
+import { Readable } from "stream";
+import { createGzip } from "zlib";
+import { a as resolveRawPackageJsonObject } from "./internal-D-ECO0sh.js";
+/*!
+ * name: tar-vern
+ * version: 0.3.0
+ * description: Tape archiver library for Typescript
+ * author: Kouji Matsui (@kekyo@mi.kekyo.net)
+ * license: MIT
+ * repository.url: https://github.com/kekyo/tar-vern.git
+ */
+const getUName = (candidateName, candidateId, reflectStat) => {
+  return "root";
 };
-const addPackFileEntry = async (pack, baseDir, path, stat2) => {
-  const writer = pack.entry({
-    name: path,
-    mode: stat2.mode,
-    mtime: stat2.mtime,
-    size: stat2.size
+const getBuffer = (data) => {
+  return Buffer.isBuffer(data) ? data : Buffer.from(data, "utf8");
+};
+const createFileItem = async (path, content, options) => {
+  var _a, _b, _c, _d, _e, _f;
+  const mode = (_a = options == null ? void 0 : options.mode) != null ? _a : 420;
+  const uid = (_b = options == null ? void 0 : options.uid) != null ? _b : 0;
+  const gid = (_c = options == null ? void 0 : options.gid) != null ? _c : 0;
+  const date = (_d = options == null ? void 0 : options.date) != null ? _d : /* @__PURE__ */ new Date();
+  const uname = (_e = options == null ? void 0 : options.uname) != null ? _e : "root";
+  const gname = (_f = options == null ? void 0 : options.gname) != null ? _f : "root";
+  return {
+    kind: "file",
+    path,
+    mode,
+    uname,
+    gname,
+    uid,
+    gid,
+    date,
+    content
+  };
+};
+const createReadableFileItem = async (path, readable, options) => {
+  var _a, _b, _c, _d, _e, _f;
+  const mode = (_a = options == null ? void 0 : options.mode) != null ? _a : 420;
+  const uid = (_b = options == null ? void 0 : options.uid) != null ? _b : 0;
+  const gid = (_c = options == null ? void 0 : options.gid) != null ? _c : 0;
+  const date = (_d = options == null ? void 0 : options.date) != null ? _d : /* @__PURE__ */ new Date();
+  const uname = (_e = options == null ? void 0 : options.uname) != null ? _e : "root";
+  const gname = (_f = options == null ? void 0 : options.gname) != null ? _f : "root";
+  let length = options == null ? void 0 : options.length;
+  if (!length) {
+    const chunks = [];
+    length = 0;
+    for await (const chunk of readable) {
+      const buffer = getBuffer(chunk);
+      chunks.push(buffer);
+      length += buffer.length;
+    }
+    return {
+      kind: "file",
+      path,
+      mode,
+      uname,
+      gname,
+      uid,
+      gid,
+      date,
+      content: {
+        kind: "readable",
+        length,
+        readable: Readable.from(chunks)
+      }
+    };
+  } else {
+    return {
+      kind: "file",
+      path,
+      mode,
+      uname,
+      gname,
+      uid,
+      gid,
+      date,
+      content: {
+        kind: "readable",
+        length,
+        readable
+      }
+    };
+  }
+};
+const createReadFileItem = async (path, filePath, reflectStat, options) => {
+  const stats = await stat(filePath);
+  const reader = createReadStream(filePath);
+  const mode = stats.mode;
+  const uid = stats.uid;
+  const gid = stats.gid;
+  const date = stats.mtime;
+  const uname = getUName(options == null ? void 0 : options.uname, stats.uid);
+  const gname = getUName(options == null ? void 0 : options.gname, stats.gid);
+  return await createReadableFileItem(path, reader, {
+    length: stats.size,
+    mode,
+    uname,
+    gname,
+    uid,
+    gid,
+    date
   });
-  const stream = createReadStream(resolve(baseDir, path));
-  stream.pipe(writer);
-  return new Promise((resolve2, reject) => {
-    stream.on("end", resolve2);
-    stream.on("error", reject);
-    writer.on("error", reject);
+};
+const storeReaderToFile = (reader, path) => {
+  const writer = createWriteStream(path);
+  reader.pipe(writer);
+  return new Promise((res, rej) => {
+    writer.on("finish", res);
+    writer.on("error", rej);
+    reader.on("error", rej);
   });
 };
-const packAssets = async (targetDir, outputDir) => {
+const utf8ByteLength = (str) => {
+  return Buffer.byteLength(str, "utf8");
+};
+const truncateUtf8Safe = (str, maxBytes) => {
+  let total = 0;
+  let i = 0;
+  while (i < str.length) {
+    const codePoint = str.codePointAt(i);
+    const char = String.fromCodePoint(codePoint);
+    const charBytes = Buffer.byteLength(char, "utf8");
+    if (total + charBytes > maxBytes) break;
+    total += charBytes;
+    i += char.length;
+  }
+  return str.slice(0, i);
+};
+const MAX_NAME = 100;
+const MAX_PREFIX = 155;
+const splitPath = (path) => {
+  var _a;
+  if (utf8ByteLength(path) <= MAX_NAME) {
+    return { prefix: "", name: path };
+  }
+  const parts = path.split("/");
+  let name = (_a = parts.pop()) != null ? _a : "";
+  let prefix = parts.join("/");
+  if (utf8ByteLength(name) > MAX_NAME) {
+    name = truncateUtf8Safe(name, MAX_NAME);
+  }
+  while (utf8ByteLength(prefix) > MAX_PREFIX) {
+    prefix = truncateUtf8Safe(prefix, MAX_PREFIX);
+  }
+  return { prefix, name };
+};
+const getOctalBytes = (value, length) => {
+  const str = value.toString(8).padStart(length - 1, "0") + "\0";
+  return Buffer.from(str, "ascii");
+};
+const getPaddedBytes = (buffer) => {
+  const extra = buffer.length % 512;
+  if (extra === 0) {
+    return buffer;
+  } else {
+    return Buffer.concat([buffer, Buffer.alloc(512 - extra, 0)]);
+  }
+};
+const terminatorBytes = Buffer.alloc(1024, 0);
+const createTarHeader = (type, path, size, mode, uname, gname, uid, gid, date) => {
+  const buffer = Buffer.alloc(512, 0);
+  const { name, prefix } = splitPath(path);
+  buffer.write(name, 0, 100, "utf8");
+  getOctalBytes(mode & 4095, 8).copy(buffer, 100);
+  getOctalBytes(uid, 8).copy(buffer, 108);
+  getOctalBytes(gid, 8).copy(buffer, 116);
+  getOctalBytes(size, 12).copy(buffer, 124);
+  getOctalBytes(Math.floor(date.getTime() / 1e3), 12).copy(buffer, 136);
+  Buffer.from("        ", "ascii").copy(buffer, 148);
+  if (type === "file") {
+    buffer.write("0", 156, 1, "ascii");
+  } else {
+    buffer.write("5", 156, 1, "ascii");
+  }
+  buffer.write("ustar\0", 257, 6, "ascii");
+  buffer.write("00", 263, 2, "ascii");
+  buffer.write(uname, 265, 32, "utf8");
+  buffer.write(gname, 297, 32, "utf8");
+  buffer.write(prefix, 345, 155, "utf8");
+  let sum = 0;
+  for (let i = 0; i < 512; i++) {
+    sum += buffer[i];
+  }
+  getOctalBytes(sum, 8).copy(buffer, 148);
+  return buffer;
+};
+const createTarPacker = (entryItemGenerator, compressionType, signal) => {
+  const entryItemIterator = async function* () {
+    for await (const entryItem of entryItemGenerator) {
+      switch (entryItem.kind) {
+        case "file": {
+          const entryItemContent = entryItem.content;
+          if (typeof entryItemContent === "string" || Buffer.isBuffer(entryItemContent)) {
+            const contentBytes = getBuffer(entryItemContent);
+            const tarHeaderBytes = createTarHeader(
+              "file",
+              entryItem.path,
+              contentBytes.length,
+              entryItem.mode,
+              entryItem.uname,
+              entryItem.gname,
+              entryItem.uid,
+              entryItem.gid,
+              entryItem.date
+            );
+            yield tarHeaderBytes;
+            const totalPaddedContentBytes = getPaddedBytes(contentBytes);
+            yield totalPaddedContentBytes;
+          } else {
+            const tarHeaderBytes = createTarHeader(
+              "file",
+              entryItem.path,
+              entryItemContent.length,
+              entryItem.mode,
+              entryItem.uname,
+              entryItem.gname,
+              entryItem.uid,
+              entryItem.gid,
+              entryItem.date
+            );
+            yield tarHeaderBytes;
+            let position = 0;
+            switch (entryItemContent.kind) {
+              case "generator": {
+                for await (const contentBytes of entryItemContent.generator) {
+                  yield contentBytes;
+                  position += contentBytes.length;
+                }
+                break;
+              }
+              case "readable": {
+                for await (const content of entryItemContent.readable) {
+                  const contentBytes = getBuffer(content);
+                  yield contentBytes;
+                  position += contentBytes.length;
+                }
+                break;
+              }
+            }
+            if (position % 512 !== 0) {
+              yield Buffer.alloc(512 - position % 512, 0);
+            }
+          }
+          break;
+        }
+        case "directory": {
+          const tarHeaderBytes = createTarHeader(
+            "directory",
+            entryItem.path,
+            0,
+            entryItem.mode,
+            entryItem.uname,
+            entryItem.gname,
+            entryItem.uid,
+            entryItem.gid,
+            entryItem.date
+          );
+          yield tarHeaderBytes;
+          break;
+        }
+      }
+    }
+    yield terminatorBytes;
+  };
+  const ct = compressionType;
+  switch (ct) {
+    case "none": {
+      return Readable.from(entryItemIterator());
+    }
+    case "gzip": {
+      const gzipStream = createGzip({ level: 9 });
+      const entryItemStream = Readable.from(entryItemIterator());
+      entryItemStream.pipe(gzipStream);
+      return gzipStream;
+    }
+  }
+};
+const createPackEntryGenerator = async function* (targetDir, resolvedPackageJson, readmeReplacementPath) {
+  var _a;
+  const packageJsonContent = JSON.stringify(resolvedPackageJson, null, 2);
+  yield await createFileItem("package/package.json", packageJsonContent);
+  const distributionFileGlobs = (_a = resolvedPackageJson == null ? void 0 : resolvedPackageJson.files) != null ? _a : ["**/*"];
+  const packingFilePaths = (await Promise.all(
+    distributionFileGlobs.map(async (pattern) => {
+      const fullPath = resolve(targetDir, pattern);
+      try {
+        if (existsSync(fullPath) && (await lstat(fullPath)).isDirectory()) {
+          return await glob(`${pattern}/**/*`, { cwd: targetDir });
+        }
+        return await glob(pattern, { cwd: targetDir });
+      } catch (error) {
+        return await glob(pattern, { cwd: targetDir });
+      }
+    })
+  )).flat();
+  for (const packingFilePath of packingFilePaths) {
+    if (packingFilePath !== "package.json") {
+      const fullPath = resolve(targetDir, packingFilePath);
+      const stat2 = await lstat(fullPath);
+      if (stat2.isFile()) {
+        if (packingFilePath === "README.md" && readmeReplacementPath) {
+          yield await createReadFileItem("package/README.md", readmeReplacementPath);
+        } else {
+          yield await createReadFileItem(`package/${packingFilePath}`, fullPath);
+        }
+      }
+    }
+  }
+  if (readmeReplacementPath && !packingFilePaths.includes("README.md")) {
+    yield await createReadFileItem("package/README.md", readmeReplacementPath);
+  }
+};
+const packAssets = async (targetDir, outputDir, checkWorkingDirectoryStatus, inheritableFields, readmeReplacementPath) => {
   var _a, _b, _c, _d;
   if (!existsSync(targetDir)) {
     return void 0;
   }
-  let resolvedPackageJson;
+  let result;
   try {
-    resolvedPackageJson = await resolveRawPackageJson(targetDir);
+    result = await resolveRawPackageJsonObject(
+      targetDir,
+      checkWorkingDirectoryStatus,
+      inheritableFields
+    );
   } catch (error) {
     return void 0;
   }
+  const { packageJson: resolvedPackageJson, sourceMap } = result;
   if (resolvedPackageJson == null ? void 0 : resolvedPackageJson.private) {
     return void 0;
   }
-  const outputFileName = `${(_b = (_a = resolvedPackageJson == null ? void 0 : resolvedPackageJson.name) == null ? void 0 : _a.replace("/", "-")) != null ? _b : "package"}-${(_c = resolvedPackageJson == null ? void 0 : resolvedPackageJson.version) != null ? _c : "0.0.0"}.tgz`;
-  const pack = tar.pack();
-  try {
-    const packageJsonContent = JSON.stringify(resolvedPackageJson, null, 2);
-    await addPackContentEntry(pack, "package.json", packageJsonContent);
-    const distributionFileGlobs = (_d = resolvedPackageJson == null ? void 0 : resolvedPackageJson.files) != null ? _d : ["**/*"];
-    const packingFilePaths = distributionFileGlobs.map((fg) => glob.sync(fg, { cwd: targetDir })).flat();
-    for (const packingFilePath of packingFilePaths) {
-      const fullPath = resolve(targetDir, packingFilePath);
-      const stat2 = await lstat(fullPath);
-      if (stat2.isFile() && packingFilePath !== "package.json") {
-        await addPackFileEntry(pack, targetDir, packingFilePath, stat2);
-      }
-    }
-    pack.finalize();
-    if (!existsSync(outputDir)) {
-      await mkdir(outputDir, { recursive: true });
+  let finalReadmeReplacementPath = readmeReplacementPath;
+  if (!finalReadmeReplacementPath && (resolvedPackageJson == null ? void 0 : resolvedPackageJson.readme)) {
+    const readmeSourceDir = (_a = sourceMap.get("readme")) != null ? _a : targetDir;
+    const packageReadmePath = resolve(readmeSourceDir, resolvedPackageJson.readme);
+    if (existsSync(packageReadmePath)) {
+      finalReadmeReplacementPath = packageReadmePath;
     }
-    const outputFile = resolve(outputDir, outputFileName);
-    const outputStream = createWriteStream(outputFile);
-    const gzip = zlib.createGzip();
-    await new Promise((resolve2, reject) => {
-      pack.pipe(gzip).pipe(outputStream);
-      outputStream.on("finish", () => resolve2());
-      outputStream.on("error", reject);
-      pack.on("error", reject);
-      gzip.on("error", reject);
-    });
-  } finally {
-    pack.destroy();
   }
+  if (finalReadmeReplacementPath && !existsSync(finalReadmeReplacementPath)) {
+    throw new Error(`README replacement file not found: ${finalReadmeReplacementPath}`);
+  }
+  const outputFileName = `${(_c = (_b = resolvedPackageJson == null ? void 0 : resolvedPackageJson.name) == null ? void 0 : _b.replace("/", "-")) != null ? _c : "package"}-${(_d = resolvedPackageJson == null ? void 0 : resolvedPackageJson.version) != null ? _d : "0.0.0"}.tgz`;
+  if (!existsSync(outputDir)) {
+    await mkdir(outputDir, { recursive: true });
+  }
+  const packer = createTarPacker(
+    createPackEntryGenerator(targetDir, resolvedPackageJson, finalReadmeReplacementPath),
+    "gzip"
+  );
+  const outputFile = resolve(outputDir, outputFileName);
+  await storeReaderToFile(packer, outputFile);
   return resolvedPackageJson;
 };
+const getComputedPackageJsonObject = async (targetDir, checkWorkingDirectoryStatus, inheritableFields) => {
+  if (!existsSync(targetDir)) {
+    return void 0;
+  }
+  const result = await resolveRawPackageJsonObject(
+    targetDir,
+    checkWorkingDirectoryStatus,
+    inheritableFields
+  );
+  return result.packageJson;
+};
 const parseArgs = (argv) => {
   const args = argv.slice(2);
   const result = {
@@ -94,7 +388,7 @@ const parseArgs = (argv) => {
       if (arg.startsWith("--")) {
         const optionName = arg.slice(2);
         const nextArg = args[i2 + 1];
-        if (nextArg && !nextArg.startsWith("-")) {
+        if (nextArg !== void 0 && !nextArg.startsWith("-")) {
           result.options[optionName] = nextArg;
           i2 += 2;
         } else {
@@ -119,7 +413,7 @@ const parseArgs = (argv) => {
     if (arg.startsWith("--")) {
       const optionName = arg.slice(2);
       const nextArg = args[i + 1];
-      if (nextArg && !nextArg.startsWith("-")) {
+      if (nextArg !== void 0 && !nextArg.startsWith("-")) {
         result.options[optionName] = nextArg;
         i += 2;
       } else {
@@ -137,8 +431,28 @@ const parseArgs = (argv) => {
   }
   return result;
 };
+const defaultInheritableFields = /* @__PURE__ */ new Set([
+  "version",
+  "description",
+  "author",
+  "license",
+  "repository",
+  "keywords",
+  "homepage",
+  "bugs",
+  "readme"
+]);
+const parseInheritableFields = (inheritableFieldsOption) => {
+  if (typeof inheritableFieldsOption !== "string") {
+    return defaultInheritableFields;
+  }
+  if (!inheritableFieldsOption.trim()) {
+    return /* @__PURE__ */ new Set();
+  }
+  return new Set(inheritableFieldsOption.split(",").map((field) => field.trim()).filter((field) => field.length > 0));
+};
 const showHelp = () => {
-  console.log(`screw-up - Easy package metadata inserter CLI [${"0.9.1"}]
+  console.log(`screw-up - Easy package metadata inserter CLI [${void 0}]
 Copyright (c) ${"Kouji Matsui (@kekyo@mi.kekyo.net)"}
 Repository: ${"https://github.com/kekyo/screw-up.git"}
 License: ${"MIT"}
@@ -148,24 +462,29 @@ Usage: screw-up <command> [options]
 Commands:
   pack [directory]              Pack the project into a tar archive
   publish [directory|package.tgz]  Publish the project
+  dump [directory]              Dump computed package.json as JSON
 
 Options:
   -h, --help                    Show help
 
 Pack Options:
   --pack-destination <path>     Directory to write the tarball
+  --readme <path>               Replace README.md with specified file
+  --inheritable-fields <list>   Comma-separated list of fields to inherit from parent (default: version,description,author,license,repository,keywords,homepage,bugs,readme)
+  --no-wds                      Do not check working directory status to increase version
 
 Publish Options:
   All npm publish options are supported (e.g., --dry-run, --tag, --access, --registry)
 
 Examples:
-  screw-up pack                          # Pack current directory
-  screw-up pack ./my-project             # Pack specific directory
-  screw-up pack --pack-destination ./dist # Pack to specific output directory
-  screw-up publish                       # Publish current directory
-  screw-up publish ./my-project          # Publish specific directory
-  screw-up publish package.tgz           # Publish existing tarball
-  screw-up publish --dry-run --tag beta  # Publish with npm options
+  screw-up pack                            # Pack current directory
+  screw-up pack ./my-project               # Pack specific directory
+  screw-up pack --pack-destination ./dist  # Pack to specific output directory
+  screw-up pack --readme ./README_pack.md  # Pack with custom README
+  screw-up publish                         # Publish current directory
+  screw-up publish ./my-project            # Publish specific directory
+  screw-up publish package.tgz             # Publish existing tarball
+  screw-up publish --dry-run --tag beta    # Publish with npm options
 `);
 };
 const showPackHelp = () => {
@@ -178,6 +497,9 @@ Arguments:
 
 Options:
   --pack-destination <path>     Directory to write the tarball
+  --readme <path>               Replace README.md with specified file
+  --inheritable-fields <list>   Comma-separated list of fields to inherit from parent
+  --no-wds                      Do not check working directory status to increase version
   -h, --help                    Show help for pack command
 `);
 };
@@ -211,11 +533,22 @@ const packCommand = async (args) => {
   }
   const directory = args.positional[0];
   const packDestination = args.options["pack-destination"];
+  const readmeOption = args.options["readme"];
+  const inheritableFieldsOption = args.options["inheritable-fields"];
+  const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
   const targetDir = resolve(directory != null ? directory : process.cwd());
   const outputDir = packDestination ? resolve(packDestination) : process.cwd();
+  const readmeReplacementPath = readmeOption ? resolve(readmeOption) : void 0;
+  const inheritableFields = parseInheritableFields(inheritableFieldsOption);
   console.log(`[screw-up/cli]: pack: Creating archive of ${targetDir}...`);
   try {
-    const metadata = await packAssets(targetDir, outputDir);
+    const metadata = await packAssets(
+      targetDir,
+      outputDir,
+      checkWorkingDirectoryStatus,
+      inheritableFields,
+      readmeReplacementPath
+    );
     if (metadata) {
       console.log(`[screw-up/cli]: pack: Archive created successfully: ${outputDir}`);
     } else {
@@ -232,7 +565,7 @@ const publishCommand = async (args) => {
     showPublishHelp();
     return;
   }
-  const runNpmPublish = async (tarballPath, npmOptions2 = []) => {
+  const runNpmPublish = async (tarballPath, npmOptions2) => {
     console.log(`[screw-up/cli]: publish: Publishing ${tarballPath} to npm...`);
     const publishArgs = ["publish", tarballPath, ...npmOptions2];
     if (process.env.SCREW_UP_TEST_MODE === "true") {
@@ -256,9 +589,12 @@ const publishCommand = async (args) => {
     });
   };
   const path = args.positional[0];
+  const inheritableFieldsOption = args.options["inheritable-fields"];
+  const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
+  const inheritableFields = parseInheritableFields(inheritableFieldsOption);
   const npmOptions = [];
   Object.entries(args.options).forEach(([key, value]) => {
-    if (key === "help" || key === "h") return;
+    if (key === "help" || key === "h" || key === "no-wds" || key === "inheritable-fields") return;
     if (value === true) {
       npmOptions.push(`--${key}`);
     } else {
@@ -271,7 +607,13 @@ const publishCommand = async (args) => {
       const outputDir = await mkdtemp("screw-up-publish-");
       console.log(`[screw-up/cli]: publish: Creating archive of ${targetDir}...`);
       try {
-        const metadata = await packAssets(targetDir, outputDir);
+        const metadata = await packAssets(
+          targetDir,
+          outputDir,
+          checkWorkingDirectoryStatus,
+          inheritableFields,
+          void 0
+        );
         if (metadata) {
           const archiveName = `${metadata.name}-${metadata.version}.tgz`;
           const archivePath = join(outputDir, archiveName);
@@ -292,7 +634,13 @@ const publishCommand = async (args) => {
         const outputDir = await mkdtemp("screw-up-publish-");
         console.log(`[screw-up/cli]: publish: Creating archive of ${targetDir}...`);
         try {
-          const metadata = await packAssets(targetDir, outputDir);
+          const metadata = await packAssets(
+            targetDir,
+            outputDir,
+            checkWorkingDirectoryStatus,
+            inheritableFields,
+            void 0
+          );
           if (metadata) {
             const archiveName = `${metadata.name}-${metadata.version}.tgz`;
             const archivePath = join(outputDir, archiveName);
@@ -317,6 +665,47 @@ const publishCommand = async (args) => {
     process.exit(1);
   }
 };
+const showDumpHelp = () => {
+  console.log(`Usage: screw-up dump [options] [directory]
+
+Dump computed package.json as JSON
+
+Arguments:
+  directory                     Directory to dump package.json from (default: current directory)
+
+Options:
+  --inheritable-fields <list>   Comma-separated list of fields to inherit from parent
+  --no-wds                      Do not check working directory status to increase version
+  -h, --help                    Show help for dump command
+`);
+};
+const dumpCommand = async (args) => {
+  if (args.options.help || args.options.h) {
+    showDumpHelp();
+    return;
+  }
+  const directory = args.positional[0];
+  const inheritableFieldsOption = args.options["inheritable-fields"];
+  const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
+  const inheritableFields = parseInheritableFields(inheritableFieldsOption);
+  const targetDir = resolve(directory != null ? directory : process.cwd());
+  try {
+    const computedPackageJson = await getComputedPackageJsonObject(
+      targetDir,
+      checkWorkingDirectoryStatus,
+      inheritableFields
+    );
+    if (computedPackageJson) {
+      console.log(JSON.stringify(computedPackageJson, null, 2));
+    } else {
+      console.error(`[screw-up/cli]: dump: Unable to read package.json from: ${targetDir}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("[screw-up/cli]: dump: Failed to dump package.json:", error);
+    process.exit(1);
+  }
+};
 const main = async () => {
   const args = parseArgs(process.argv);
   if (args.options.help || args.options.h || !args.command || args.command === "help" || args.command === "--help") {
@@ -330,6 +719,9 @@ const main = async () => {
     case "publish":
       await publishCommand(args);
       break;
+    case "dump":
+      await dumpCommand(args);
+      break;
     default:
       console.error(`Unknown command: ${args.command}`);
       console.error('Run "screw-up --help" for usage information.');
@@ -340,3 +732,4 @@ main().catch((error) => {
   console.error("CLI error:", error);
   process.exit(1);
 });
+//# sourceMappingURL=cli.js.map