screw-up 0.8.1 → 0.9.1

package/README.md

@@ -49,6 +49,7 @@ To insert banner header each bundled source files (`dist/index.js` and etc.):
 * Nested object support: Handles nested objects like `author.name`, `repository.url`.
 * Customizable: Choose which metadata fields to include in your banner.
 * TypeScript metadata generation: Automatically generates TypeScript files with metadata constants for use in your source code.
+* Supported pack/publish CLI interface. When publishing using this feature, the package is generated after applying the above processing to `package.json`.
 
 ## Installation
 
@@ -295,6 +296,84 @@ The plugin automatically detects and supports:
 
 ----
 
+## CLI Usage
+
+The `screw-up` package includes a command-line interface for packaging and publishing your projects.
+
+### Pack Command
+
+Create a tar archive of your project:
+
+```bash
+# Pack current directory
+screw-up pack
+
+# Pack specific directory
+screw-up pack ./my-project
+
+# Pack to specific output directory
+screw-up pack --pack-destination ./dist
+```
+
+The pack command:
+
+- Automatically reads `package.json` for metadata and file inclusion rules
+- Respects the `files` field in your `package.json`
+- Supports workspace inheritance (inherits metadata from parent packages)
+- Creates a compressed `.tgz` archive with format: `{name}-{version}.tgz`
+
+### Publish Command
+
+Publish your project to registry server:
+
+```bash
+# Publish current directory (creates archive and publishes)
+screw-up publish
+
+# Publish specific directory
+screw-up publish ./my-project
+
+# Publish existing tarball
+screw-up publish package.tgz
+
+# Publish with npm options (all npm publish options are supported)
+screw-up publish --dry-run --tag beta --access public
+```
+
+The publish command:
+
+- Supports all `npm publish` options transparently
+- Can publish from directory (automatically creates archive) or existing tarball
+- Handles workspace packages with proper metadata inheritance
+- Uses the same packaging logic as the pack command
+
+### Examples
+
+```bash
+# Build and publish with dry run
+screw-up publish --dry-run
+
+# Publish to beta channel
+screw-up publish --tag beta
+
+# Publish scoped package as public
+screw-up publish --access public
+
+# Pack to custom directory then publish
+screw-up pack --pack-destination ./release
+screw-up publish ./release/my-package-1.0.0.tgz
+```
+
+For help with any command:
+
+```bash
+screw-up --help
+screw-up pack --help
+screw-up publish --help
+```
+
+----
+
 ## License
 
 Under MIT

package/dist/cli-internal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Pack assets into a tar archive
+ * @param targetDir - Target directory to pack
+ * @param outputDir - Output directory to write the tarball
+ * @returns Package metadata (package.json) or undefined if failed
+ */
+export declare const packAssets: (targetDir: string, outputDir: string) => Promise<any>;
+export interface ParsedArgs {
+    command?: string;
+    positional: string[];
+    options: Record<string, string | boolean>;
+}
+export declare const parseArgs: (argv: string[]) => ParsedArgs;
+//# sourceMappingURL=cli-internal.d.ts.map

package/dist/cli-internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-internal.d.ts","sourceRoot":"","sources":["../src/cli-internal.ts"],"names":[],"mappings":"AAyCA;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAU,WAAW,MAAM,EAAE,WAAW,MAAM,KAAI,OAAO,CAAC,GAAG,CA2EnF,CAAC;AAIF,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC;CAC3C;AAED,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,EAAE,KAAG,UAoE1C,CAAC"}

package/dist/cli.cjs

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+"use strict";
+const path = require("path");
+const fs = require("fs");
+const promises = require("fs/promises");
+const child_process = require("child_process");
+const glob = require("glob");
+const internal = require("./internal-BJ2gdqpB.cjs");
+const tar = require("tar-stream");
+const zlib = require("zlib");
+const addPackContentEntry = async (pack, name, content) => {
+  pack.entry({
+    name,
+    type: "file",
+    mode: 420,
+    mtime: /* @__PURE__ */ new Date(),
+    size: Buffer.byteLength(content, "utf8")
+  }, content);
+};
+const addPackFileEntry = async (pack, baseDir, path$1, stat) => {
+  const writer = pack.entry({
+    name: path$1,
+    mode: stat.mode,
+    mtime: stat.mtime,
+    size: stat.size
+  });
+  const stream = fs.createReadStream(path.resolve(baseDir, path$1));
+  stream.pipe(writer);
+  return new Promise((resolve2, reject) => {
+    stream.on("end", resolve2);
+    stream.on("error", reject);
+    writer.on("error", reject);
+  });
+};
+const packAssets = async (targetDir, outputDir) => {
+  var _a, _b, _c, _d;
+  if (!fs.existsSync(targetDir)) {
+    return void 0;
+  }
+  let resolvedPackageJson;
+  try {
+    resolvedPackageJson = await internal.resolveRawPackageJson(targetDir);
+  } catch (error) {
+    return void 0;
+  }
+  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.glob.sync(fg, { cwd: targetDir })).flat();
+    for (const packingFilePath of packingFilePaths) {
+      const fullPath = path.resolve(targetDir, packingFilePath);
+      const stat = await promises.lstat(fullPath);
+      if (stat.isFile() && packingFilePath !== "package.json") {
+        await addPackFileEntry(pack, targetDir, packingFilePath, stat);
+      }
+    }
+    pack.finalize();
+    if (!fs.existsSync(outputDir)) {
+      await promises.mkdir(outputDir, { recursive: true });
+    }
+    const outputFile = path.resolve(outputDir, outputFileName);
+    const outputStream = fs.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();
+  }
+  return resolvedPackageJson;
+};
+const parseArgs = (argv) => {
+  const args = argv.slice(2);
+  const result = {
+    positional: [],
+    options: {}
+  };
+  if (args.length === 0) {
+    return result;
+  }
+  if (args[0].startsWith("-")) {
+    let i2 = 0;
+    while (i2 < args.length) {
+      const arg = args[i2];
+      if (arg.startsWith("--")) {
+        const optionName = arg.slice(2);
+        const nextArg = args[i2 + 1];
+        if (nextArg && !nextArg.startsWith("-")) {
+          result.options[optionName] = nextArg;
+          i2 += 2;
+        } else {
+          result.options[optionName] = true;
+          i2 += 1;
+        }
+      } else if (arg.startsWith("-")) {
+        const optionName = arg.slice(1);
+        result.options[optionName] = true;
+        i2 += 1;
+      } else {
+        result.positional.push(arg);
+        i2 += 1;
+      }
+    }
+    return result;
+  }
+  result.command = args[0];
+  let i = 1;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const optionName = arg.slice(2);
+      const nextArg = args[i + 1];
+      if (nextArg && !nextArg.startsWith("-")) {
+        result.options[optionName] = nextArg;
+        i += 2;
+      } else {
+        result.options[optionName] = true;
+        i += 1;
+      }
+    } else if (arg.startsWith("-")) {
+      const optionName = arg.slice(1);
+      result.options[optionName] = true;
+      i += 1;
+    } else {
+      result.positional.push(arg);
+      i += 1;
+    }
+  }
+  return result;
+};
+const showHelp = () => {
+  console.log(`screw-up - Easy package metadata inserter CLI [${"0.9.1"}]
+Copyright (c) ${"Kouji Matsui (@kekyo@mi.kekyo.net)"}
+Repository: ${"https://github.com/kekyo/screw-up.git"}
+License: ${"MIT"}
+
+Usage: screw-up <command> [options]
+
+Commands:
+  pack [directory]              Pack the project into a tar archive
+  publish [directory|package.tgz]  Publish the project
+
+Options:
+  -h, --help                    Show help
+
+Pack Options:
+  --pack-destination <path>     Directory to write the tarball
+
+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
+`);
+};
+const showPackHelp = () => {
+  console.log(`Usage: screw-up pack [options] [directory]
+
+Pack the project into a tar archive
+
+Arguments:
+  directory                     Directory to pack (default: current directory)
+
+Options:
+  --pack-destination <path>     Directory to write the tarball
+  -h, --help                    Show help for pack command
+`);
+};
+const showPublishHelp = () => {
+  console.log(`Usage: screw-up publish [options] [directory|package.tgz]
+
+Publish the project
+
+Arguments:
+  directory|package.tgz         Directory to pack and publish, or existing tarball to publish
+
+Options:
+  All npm publish options are supported, including:
+  --dry-run                     Perform a dry run
+  --tag <tag>                   Tag for the published version
+  --access <access>             Access level (public or restricted)
+  --registry <registry>         Registry URL
+  -h, --help                    Show help for publish command
+
+Examples:
+  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 options
+`);
+};
+const packCommand = async (args) => {
+  if (args.options.help || args.options.h) {
+    showPackHelp();
+    return;
+  }
+  const directory = args.positional[0];
+  const packDestination = args.options["pack-destination"];
+  const targetDir = path.resolve(directory != null ? directory : process.cwd());
+  const outputDir = packDestination ? path.resolve(packDestination) : process.cwd();
+  console.log(`[screw-up/cli]: pack: Creating archive of ${targetDir}...`);
+  try {
+    const metadata = await packAssets(targetDir, outputDir);
+    if (metadata) {
+      console.log(`[screw-up/cli]: pack: Archive created successfully: ${outputDir}`);
+    } else {
+      console.error(`[screw-up/cli]: pack: Unable to find any files to pack: ${targetDir}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("[screw-up/cli]: pack: Failed to create archive:", error);
+    process.exit(1);
+  }
+};
+const publishCommand = async (args) => {
+  if (args.options.help || args.options.h) {
+    showPublishHelp();
+    return;
+  }
+  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") {
+      console.log(`[screw-up/cli]: TEST_MODE: Would execute: npm ${publishArgs.join(" ")}`);
+      console.log(`[screw-up/cli]: TEST_MODE: Tarball path: ${tarballPath}`);
+      console.log(`[screw-up/cli]: TEST_MODE: Options: ${npmOptions2.join(" ")}`);
+      console.log(`[screw-up/cli]: publish: Successfully published ${tarballPath}`);
+      return;
+    }
+    const npmProcess = child_process.spawn("npm", publishArgs, { stdio: "inherit" });
+    return new Promise((resolve2, reject) => {
+      npmProcess.on("close", (code) => {
+        if (code === 0) {
+          console.log(`[screw-up/cli]: publish: Successfully published ${tarballPath}`);
+          resolve2();
+        } else {
+          reject(new Error(`npm publish failed with exit code ${code}`));
+        }
+      });
+      npmProcess.on("error", reject);
+    });
+  };
+  const path$1 = args.positional[0];
+  const npmOptions = [];
+  Object.entries(args.options).forEach(([key, value]) => {
+    if (key === "help" || key === "h") return;
+    if (value === true) {
+      npmOptions.push(`--${key}`);
+    } else {
+      npmOptions.push(`--${key}`, value);
+    }
+  });
+  try {
+    if (!path$1) {
+      const targetDir = process.cwd();
+      const outputDir = await promises.mkdtemp("screw-up-publish-");
+      console.log(`[screw-up/cli]: publish: Creating archive of ${targetDir}...`);
+      try {
+        const metadata = await packAssets(targetDir, outputDir);
+        if (metadata) {
+          const archiveName = `${metadata.name}-${metadata.version}.tgz`;
+          const archivePath = path.join(outputDir, archiveName);
+          await runNpmPublish(archivePath, npmOptions);
+        } else {
+          console.error(`[screw-up/cli]: publish: Unable to find any files to pack: ${targetDir}`);
+          process.exit(1);
+        }
+      } finally {
+        await promises.rm(outputDir, { recursive: true, force: true });
+      }
+    } else if (fs.existsSync(path$1)) {
+      const pathStat = await promises.stat(path$1);
+      if (pathStat.isFile() && (path$1.endsWith(".tgz") || path$1.endsWith(".tar.gz"))) {
+        await runNpmPublish(path.resolve(path$1), npmOptions);
+      } else if (pathStat.isDirectory()) {
+        const targetDir = path.resolve(path$1);
+        const outputDir = await promises.mkdtemp("screw-up-publish-");
+        console.log(`[screw-up/cli]: publish: Creating archive of ${targetDir}...`);
+        try {
+          const metadata = await packAssets(targetDir, outputDir);
+          if (metadata) {
+            const archiveName = `${metadata.name}-${metadata.version}.tgz`;
+            const archivePath = path.join(outputDir, archiveName);
+            await runNpmPublish(archivePath, npmOptions);
+          } else {
+            console.error(`[screw-up/cli]: publish: Unable to find any files to pack: ${targetDir}`);
+            process.exit(1);
+          }
+        } finally {
+          await promises.rm(outputDir, { recursive: true, force: true });
+        }
+      } else {
+        console.error(`[screw-up/cli]: publish: Invalid path - must be a directory or .tgz/.tar.gz file: ${path$1}`);
+        process.exit(1);
+      }
+    } else {
+      console.error(`[screw-up/cli]: publish: Path does not exist: ${path$1}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("[screw-up/cli]: publish: Failed to publish:", 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") {
+    showHelp();
+    return;
+  }
+  switch (args.command) {
+    case "pack":
+      await packCommand(args);
+      break;
+    case "publish":
+      await publishCommand(args);
+      break;
+    default:
+      console.error(`Unknown command: ${args.command}`);
+      console.error('Run "screw-up --help" for usage information.');
+      process.exit(1);
+  }
+};
+main().catch((error) => {
+  console.error("CLI error:", error);
+  process.exit(1);
+});

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,342 @@
+#!/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 { 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);
+};
+const addPackFileEntry = async (pack, baseDir, path, stat2) => {
+  const writer = pack.entry({
+    name: path,
+    mode: stat2.mode,
+    mtime: stat2.mtime,
+    size: stat2.size
+  });
+  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 packAssets = async (targetDir, outputDir) => {
+  var _a, _b, _c, _d;
+  if (!existsSync(targetDir)) {
+    return void 0;
+  }
+  let resolvedPackageJson;
+  try {
+    resolvedPackageJson = await resolveRawPackageJson(targetDir);
+  } catch (error) {
+    return void 0;
+  }
+  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 });
+    }
+    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();
+  }
+  return resolvedPackageJson;
+};
+const parseArgs = (argv) => {
+  const args = argv.slice(2);
+  const result = {
+    positional: [],
+    options: {}
+  };
+  if (args.length === 0) {
+    return result;
+  }
+  if (args[0].startsWith("-")) {
+    let i2 = 0;
+    while (i2 < args.length) {
+      const arg = args[i2];
+      if (arg.startsWith("--")) {
+        const optionName = arg.slice(2);
+        const nextArg = args[i2 + 1];
+        if (nextArg && !nextArg.startsWith("-")) {
+          result.options[optionName] = nextArg;
+          i2 += 2;
+        } else {
+          result.options[optionName] = true;
+          i2 += 1;
+        }
+      } else if (arg.startsWith("-")) {
+        const optionName = arg.slice(1);
+        result.options[optionName] = true;
+        i2 += 1;
+      } else {
+        result.positional.push(arg);
+        i2 += 1;
+      }
+    }
+    return result;
+  }
+  result.command = args[0];
+  let i = 1;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const optionName = arg.slice(2);
+      const nextArg = args[i + 1];
+      if (nextArg && !nextArg.startsWith("-")) {
+        result.options[optionName] = nextArg;
+        i += 2;
+      } else {
+        result.options[optionName] = true;
+        i += 1;
+      }
+    } else if (arg.startsWith("-")) {
+      const optionName = arg.slice(1);
+      result.options[optionName] = true;
+      i += 1;
+    } else {
+      result.positional.push(arg);
+      i += 1;
+    }
+  }
+  return result;
+};
+const showHelp = () => {
+  console.log(`screw-up - Easy package metadata inserter CLI [${"0.9.1"}]
+Copyright (c) ${"Kouji Matsui (@kekyo@mi.kekyo.net)"}
+Repository: ${"https://github.com/kekyo/screw-up.git"}
+License: ${"MIT"}
+
+Usage: screw-up <command> [options]
+
+Commands:
+  pack [directory]              Pack the project into a tar archive
+  publish [directory|package.tgz]  Publish the project
+
+Options:
+  -h, --help                    Show help
+
+Pack Options:
+  --pack-destination <path>     Directory to write the tarball
+
+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
+`);
+};
+const showPackHelp = () => {
+  console.log(`Usage: screw-up pack [options] [directory]
+
+Pack the project into a tar archive
+
+Arguments:
+  directory                     Directory to pack (default: current directory)
+
+Options:
+  --pack-destination <path>     Directory to write the tarball
+  -h, --help                    Show help for pack command
+`);
+};
+const showPublishHelp = () => {
+  console.log(`Usage: screw-up publish [options] [directory|package.tgz]
+
+Publish the project
+
+Arguments:
+  directory|package.tgz         Directory to pack and publish, or existing tarball to publish
+
+Options:
+  All npm publish options are supported, including:
+  --dry-run                     Perform a dry run
+  --tag <tag>                   Tag for the published version
+  --access <access>             Access level (public or restricted)
+  --registry <registry>         Registry URL
+  -h, --help                    Show help for publish command
+
+Examples:
+  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 options
+`);
+};
+const packCommand = async (args) => {
+  if (args.options.help || args.options.h) {
+    showPackHelp();
+    return;
+  }
+  const directory = args.positional[0];
+  const packDestination = args.options["pack-destination"];
+  const targetDir = resolve(directory != null ? directory : process.cwd());
+  const outputDir = packDestination ? resolve(packDestination) : process.cwd();
+  console.log(`[screw-up/cli]: pack: Creating archive of ${targetDir}...`);
+  try {
+    const metadata = await packAssets(targetDir, outputDir);
+    if (metadata) {
+      console.log(`[screw-up/cli]: pack: Archive created successfully: ${outputDir}`);
+    } else {
+      console.error(`[screw-up/cli]: pack: Unable to find any files to pack: ${targetDir}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("[screw-up/cli]: pack: Failed to create archive:", error);
+    process.exit(1);
+  }
+};
+const publishCommand = async (args) => {
+  if (args.options.help || args.options.h) {
+    showPublishHelp();
+    return;
+  }
+  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") {
+      console.log(`[screw-up/cli]: TEST_MODE: Would execute: npm ${publishArgs.join(" ")}`);
+      console.log(`[screw-up/cli]: TEST_MODE: Tarball path: ${tarballPath}`);
+      console.log(`[screw-up/cli]: TEST_MODE: Options: ${npmOptions2.join(" ")}`);
+      console.log(`[screw-up/cli]: publish: Successfully published ${tarballPath}`);
+      return;
+    }
+    const npmProcess = spawn("npm", publishArgs, { stdio: "inherit" });
+    return new Promise((resolve2, reject) => {
+      npmProcess.on("close", (code) => {
+        if (code === 0) {
+          console.log(`[screw-up/cli]: publish: Successfully published ${tarballPath}`);
+          resolve2();
+        } else {
+          reject(new Error(`npm publish failed with exit code ${code}`));
+        }
+      });
+      npmProcess.on("error", reject);
+    });
+  };
+  const path = args.positional[0];
+  const npmOptions = [];
+  Object.entries(args.options).forEach(([key, value]) => {
+    if (key === "help" || key === "h") return;
+    if (value === true) {
+      npmOptions.push(`--${key}`);
+    } else {
+      npmOptions.push(`--${key}`, value);
+    }
+  });
+  try {
+    if (!path) {
+      const targetDir = process.cwd();
+      const outputDir = await mkdtemp("screw-up-publish-");
+      console.log(`[screw-up/cli]: publish: Creating archive of ${targetDir}...`);
+      try {
+        const metadata = await packAssets(targetDir, outputDir);
+        if (metadata) {
+          const archiveName = `${metadata.name}-${metadata.version}.tgz`;
+          const archivePath = join(outputDir, archiveName);
+          await runNpmPublish(archivePath, npmOptions);
+        } else {
+          console.error(`[screw-up/cli]: publish: Unable to find any files to pack: ${targetDir}`);
+          process.exit(1);
+        }
+      } finally {
+        await rm(outputDir, { recursive: true, force: true });
+      }
+    } else if (existsSync(path)) {
+      const pathStat = await stat(path);
+      if (pathStat.isFile() && (path.endsWith(".tgz") || path.endsWith(".tar.gz"))) {
+        await runNpmPublish(resolve(path), npmOptions);
+      } else if (pathStat.isDirectory()) {
+        const targetDir = resolve(path);
+        const outputDir = await mkdtemp("screw-up-publish-");
+        console.log(`[screw-up/cli]: publish: Creating archive of ${targetDir}...`);
+        try {
+          const metadata = await packAssets(targetDir, outputDir);
+          if (metadata) {
+            const archiveName = `${metadata.name}-${metadata.version}.tgz`;
+            const archivePath = join(outputDir, archiveName);
+            await runNpmPublish(archivePath, npmOptions);
+          } else {
+            console.error(`[screw-up/cli]: publish: Unable to find any files to pack: ${targetDir}`);
+            process.exit(1);
+          }
+        } finally {
+          await rm(outputDir, { recursive: true, force: true });
+        }
+      } else {
+        console.error(`[screw-up/cli]: publish: Invalid path - must be a directory or .tgz/.tar.gz file: ${path}`);
+        process.exit(1);
+      }
+    } else {
+      console.error(`[screw-up/cli]: publish: Path does not exist: ${path}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("[screw-up/cli]: publish: Failed to publish:", 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") {
+    showHelp();
+    return;
+  }
+  switch (args.command) {
+    case "pack":
+      await packCommand(args);
+      break;
+    case "publish":
+      await publishCommand(args);
+      break;
+    default:
+      console.error(`Unknown command: ${args.command}`);
+      console.error('Run "screw-up --help" for usage information.');
+      process.exit(1);
+  }
+};
+main().catch((error) => {
+  console.error("CLI error:", error);
+  process.exit(1);
+});

package/dist/index.cjs

@@ -1,85 +1,8 @@
 "use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const promises = require("fs/promises");
 const path = require("path");
-const fs = require("fs");
-const flattenObject = (obj, prefix, map) => {
-  for (const [key, value] of Object.entries(obj)) {
-    if (!value)
-      continue;
-    const fullKey = prefix ? `${prefix}.${key}` : key;
-    if (typeof value === "string") {
-      map[fullKey] = value;
-    } else if (Array.isArray(value)) {
-      map[fullKey] = value.map((v) => String(v)).join(",");
-    } else if (typeof value === "object") {
-      flattenObject(value, fullKey, map);
-    } else {
-      map[fullKey] = String(value);
-    }
-  }
-};
-const readPackageMetadata = async (packagePath) => {
-  try {
-    const content = await promises.readFile(packagePath, "utf-8");
-    const json = JSON.parse(content);
-    const map = {};
-    flattenObject(json, "", map);
-    return map;
-  } catch (error) {
-    console.warn(`Failed to read package.json from ${packagePath}:`, error);
-    return {};
-  }
-};
-const findWorkspaceRoot = async (startPath) => {
-  let currentPath = startPath;
-  while (currentPath !== path.dirname(currentPath)) {
-    const packageJsonPath = path.join(currentPath, "package.json");
-    if (fs.existsSync(packageJsonPath)) {
-      try {
-        const content = await promises.readFile(packageJsonPath, "utf-8");
-        const packageJson = JSON.parse(content);
-        if (packageJson.workspaces || fs.existsSync(path.join(currentPath, "pnpm-workspace.yaml")) || fs.existsSync(path.join(currentPath, "lerna.json"))) {
-          return currentPath;
-        }
-      } catch (error) {
-        console.warn(`Failed to parse package.json at ${packageJsonPath}:`, error);
-      }
-    }
-    currentPath = path.dirname(currentPath);
-  }
-  return void 0;
-};
-const mergePackageMetadata = (parentMetadata, childMetadata) => {
-  const merged = {};
-  for (const key in parentMetadata) {
-    const value = parentMetadata[key];
-    if (value !== void 0) {
-      merged[key] = value;
-    }
-  }
-  for (const key in childMetadata) {
-    const value = childMetadata[key];
-    if (value !== void 0) {
-      merged[key] = value;
-    }
-  }
-  return merged;
-};
-const resolvePackageMetadata = async (projectRoot) => {
-  const workspaceRoot = await findWorkspaceRoot(projectRoot);
-  if (!workspaceRoot) {
-    const localPackagePath = path.join(projectRoot, "package.json");
-    return await readPackageMetadata(localPackagePath);
-  }
-  const projectPackagePath = path.join(projectRoot, "package.json");
-  const rootPackagePath = path.join(workspaceRoot, "package.json");
-  let metadata = await readPackageMetadata(rootPackagePath);
-  if (projectPackagePath !== rootPackagePath && fs.existsSync(projectPackagePath)) {
-    const projectMetadata = await readPackageMetadata(projectPackagePath);
-    metadata = mergePackageMetadata(metadata, projectMetadata);
-  }
-  return metadata;
-};
+const internal = require("./internal-BJ2gdqpB.cjs");
 const generateBanner = (metadata, outputKeys) => {
   const parts = [];
   for (const key of outputKeys) {
@@ -136,7 +59,7 @@ const screwUp = (options = {}) => {
     apply: "build",
     async configResolved(config) {
       projectRoot = config.root;
-      metadata = await resolvePackageMetadata(config.root);
+      metadata = await internal.resolvePackageMetadata(config.root);
       banner = generateBanner(metadata, outputKeys);
     },
     async buildStart() {
@@ -184,4 +107,5 @@ const screwUp = (options = {}) => {
     }
   };
 };
-module.exports = screwUp;
+exports.default = screwUp;
+exports.generateBanner = generateBanner;

package/dist/index.d.ts

@@ -1,5 +1,13 @@
 import { Plugin } from 'vite';
+import { PackageMetadata } from './internal.js';
 
+/**
+ * Generate banner string from package.json metadata
+ * @param metadata - Package metadata
+ * @param outputKeys - Array of keys to output in specified order
+ * @returns Banner string
+ */
+export declare const generateBanner: (metadata: PackageMetadata, outputKeys: string[]) => string;
 /**
  * screw-up options
  */

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAKnC;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED;;;;GAIG;AACH,QAAA,MAAM,OAAO,GAAI,UAAS,cAAmB,KAAG,MAiF/C,CAAC;AAEF,eAAe,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAGnC,OAAO,EAAE,eAAe,EAA0B,MAAM,eAAe,CAAC;AAExE;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,eAAe,EAAE,YAAY,MAAM,EAAE,KAAG,MAWhF,CAAC;AA4DF;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED;;;;GAIG;AACH,QAAA,MAAM,OAAO,GAAI,UAAS,cAAmB,KAAG,MAiF/C,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/index.js

@@ -1,84 +1,6 @@
-import { readFile, readdir, writeFile, mkdir } from "fs/promises";
+import { readdir, readFile, writeFile, mkdir } from "fs/promises";
 import { join, dirname } from "path";
-import { existsSync } from "fs";
-const flattenObject = (obj, prefix, map) => {
-  for (const [key, value] of Object.entries(obj)) {
-    if (!value)
-      continue;
-    const fullKey = prefix ? `${prefix}.${key}` : key;
-    if (typeof value === "string") {
-      map[fullKey] = value;
-    } else if (Array.isArray(value)) {
-      map[fullKey] = value.map((v) => String(v)).join(",");
-    } else if (typeof value === "object") {
-      flattenObject(value, fullKey, map);
-    } else {
-      map[fullKey] = String(value);
-    }
-  }
-};
-const readPackageMetadata = async (packagePath) => {
-  try {
-    const content = await readFile(packagePath, "utf-8");
-    const json = JSON.parse(content);
-    const map = {};
-    flattenObject(json, "", map);
-    return map;
-  } catch (error) {
-    console.warn(`Failed to read package.json from ${packagePath}:`, error);
-    return {};
-  }
-};
-const findWorkspaceRoot = async (startPath) => {
-  let currentPath = startPath;
-  while (currentPath !== dirname(currentPath)) {
-    const packageJsonPath = join(currentPath, "package.json");
-    if (existsSync(packageJsonPath)) {
-      try {
-        const content = await readFile(packageJsonPath, "utf-8");
-        const packageJson = JSON.parse(content);
-        if (packageJson.workspaces || existsSync(join(currentPath, "pnpm-workspace.yaml")) || existsSync(join(currentPath, "lerna.json"))) {
-          return currentPath;
-        }
-      } catch (error) {
-        console.warn(`Failed to parse package.json at ${packageJsonPath}:`, error);
-      }
-    }
-    currentPath = dirname(currentPath);
-  }
-  return void 0;
-};
-const mergePackageMetadata = (parentMetadata, childMetadata) => {
-  const merged = {};
-  for (const key in parentMetadata) {
-    const value = parentMetadata[key];
-    if (value !== void 0) {
-      merged[key] = value;
-    }
-  }
-  for (const key in childMetadata) {
-    const value = childMetadata[key];
-    if (value !== void 0) {
-      merged[key] = value;
-    }
-  }
-  return merged;
-};
-const resolvePackageMetadata = async (projectRoot) => {
-  const workspaceRoot = await findWorkspaceRoot(projectRoot);
-  if (!workspaceRoot) {
-    const localPackagePath = join(projectRoot, "package.json");
-    return await readPackageMetadata(localPackagePath);
-  }
-  const projectPackagePath = join(projectRoot, "package.json");
-  const rootPackagePath = join(workspaceRoot, "package.json");
-  let metadata = await readPackageMetadata(rootPackagePath);
-  if (projectPackagePath !== rootPackagePath && existsSync(projectPackagePath)) {
-    const projectMetadata = await readPackageMetadata(projectPackagePath);
-    metadata = mergePackageMetadata(metadata, projectMetadata);
-  }
-  return metadata;
-};
+import { r as resolvePackageMetadata } from "./internal-JwF_Mrdt.js";
 const generateBanner = (metadata, outputKeys) => {
   const parts = [];
   for (const key of outputKeys) {
@@ -184,5 +106,6 @@ const screwUp = (options = {}) => {
   };
 };
 export {
-  screwUp as default
+  screwUp as default,
+  generateBanner
 };

package/dist/internal-BJ2gdqpB.cjs

@@ -0,0 +1,119 @@
+"use strict";
+const fs = require("fs");
+const promises = require("fs/promises");
+const path = require("path");
+const flattenObject = (obj, prefix, map) => {
+  for (const [key, value] of Object.entries(obj)) {
+    if (!value)
+      continue;
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "string") {
+      map[fullKey] = value;
+    } else if (Array.isArray(value)) {
+      map[fullKey] = value.map((v) => String(v)).join(",");
+    } else if (typeof value === "object") {
+      flattenObject(value, fullKey, map);
+    } else {
+      map[fullKey] = String(value);
+    }
+  }
+};
+const readPackageMetadata = async (packagePath) => {
+  try {
+    const content = await promises.readFile(packagePath, "utf-8");
+    const json = JSON.parse(content);
+    const map = {};
+    flattenObject(json, "", map);
+    return map;
+  } catch (error) {
+    console.warn(`Failed to read package.json from ${packagePath}:`, error);
+    return {};
+  }
+};
+const findWorkspaceRoot = async (startPath) => {
+  let currentPath = startPath;
+  while (currentPath !== path.dirname(currentPath)) {
+    const packageJsonPath = path.join(currentPath, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const content = await promises.readFile(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(content);
+        if (packageJson.workspaces || fs.existsSync(path.join(currentPath, "pnpm-workspace.yaml")) || fs.existsSync(path.join(currentPath, "lerna.json"))) {
+          return currentPath;
+        }
+      } catch (error) {
+        console.warn(`Failed to parse package.json at ${packageJsonPath}:`, error);
+      }
+    }
+    currentPath = path.dirname(currentPath);
+  }
+  return void 0;
+};
+const mergePackageMetadata = (parentMetadata, childMetadata) => {
+  const merged = {};
+  for (const key in parentMetadata) {
+    const value = parentMetadata[key];
+    if (value !== void 0) {
+      merged[key] = value;
+    }
+  }
+  for (const key in childMetadata) {
+    const value = childMetadata[key];
+    if (value !== void 0) {
+      merged[key] = value;
+    }
+  }
+  return merged;
+};
+const resolvePackageMetadataT = async (projectRoot, readPackageMetadataFn, mergePackageMetadataFn) => {
+  const workspaceRoot = await findWorkspaceRoot(projectRoot);
+  if (!workspaceRoot) {
+    const localPackagePath = path.join(projectRoot, "package.json");
+    return await readPackageMetadataFn(localPackagePath);
+  }
+  const projectPackagePath = path.join(projectRoot, "package.json");
+  const rootPackagePath = path.join(workspaceRoot, "package.json");
+  const metadata = await readPackageMetadataFn(rootPackagePath);
+  if (projectPackagePath !== rootPackagePath && fs.existsSync(projectPackagePath)) {
+    const projectMetadata = await readPackageMetadataFn(projectPackagePath);
+    return mergePackageMetadataFn(metadata, projectMetadata);
+  } else {
+    return metadata;
+  }
+};
+const readRawPackageJson = async (packagePath) => {
+  try {
+    const content = await promises.readFile(packagePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`Failed to read package.json from ${packagePath}:`, error);
+    throw error;
+  }
+};
+const mergeRawPackageJson = (parentPackage, childPackage) => {
+  const inheritableFields = [
+    "version",
+    "description",
+    "author",
+    "license",
+    "repository",
+    "keywords",
+    "homepage",
+    "bugs"
+  ];
+  const merged = { ...childPackage };
+  for (const field of inheritableFields) {
+    if (parentPackage[field] && !merged[field]) {
+      merged[field] = parentPackage[field];
+    }
+  }
+  return merged;
+};
+const resolvePackageMetadata = (projectRoot) => {
+  return resolvePackageMetadataT(projectRoot, readPackageMetadata, mergePackageMetadata);
+};
+const resolveRawPackageJson = (projectRoot) => {
+  return resolvePackageMetadataT(projectRoot, readRawPackageJson, mergeRawPackageJson);
+};
+exports.resolvePackageMetadata = resolvePackageMetadata;
+exports.resolveRawPackageJson = resolveRawPackageJson;

package/dist/internal-JwF_Mrdt.js

@@ -0,0 +1,120 @@
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { join, dirname } from "path";
+const flattenObject = (obj, prefix, map) => {
+  for (const [key, value] of Object.entries(obj)) {
+    if (!value)
+      continue;
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "string") {
+      map[fullKey] = value;
+    } else if (Array.isArray(value)) {
+      map[fullKey] = value.map((v) => String(v)).join(",");
+    } else if (typeof value === "object") {
+      flattenObject(value, fullKey, map);
+    } else {
+      map[fullKey] = String(value);
+    }
+  }
+};
+const readPackageMetadata = async (packagePath) => {
+  try {
+    const content = await readFile(packagePath, "utf-8");
+    const json = JSON.parse(content);
+    const map = {};
+    flattenObject(json, "", map);
+    return map;
+  } catch (error) {
+    console.warn(`Failed to read package.json from ${packagePath}:`, error);
+    return {};
+  }
+};
+const findWorkspaceRoot = async (startPath) => {
+  let currentPath = startPath;
+  while (currentPath !== dirname(currentPath)) {
+    const packageJsonPath = join(currentPath, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const content = await readFile(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(content);
+        if (packageJson.workspaces || existsSync(join(currentPath, "pnpm-workspace.yaml")) || existsSync(join(currentPath, "lerna.json"))) {
+          return currentPath;
+        }
+      } catch (error) {
+        console.warn(`Failed to parse package.json at ${packageJsonPath}:`, error);
+      }
+    }
+    currentPath = dirname(currentPath);
+  }
+  return void 0;
+};
+const mergePackageMetadata = (parentMetadata, childMetadata) => {
+  const merged = {};
+  for (const key in parentMetadata) {
+    const value = parentMetadata[key];
+    if (value !== void 0) {
+      merged[key] = value;
+    }
+  }
+  for (const key in childMetadata) {
+    const value = childMetadata[key];
+    if (value !== void 0) {
+      merged[key] = value;
+    }
+  }
+  return merged;
+};
+const resolvePackageMetadataT = async (projectRoot, readPackageMetadataFn, mergePackageMetadataFn) => {
+  const workspaceRoot = await findWorkspaceRoot(projectRoot);
+  if (!workspaceRoot) {
+    const localPackagePath = join(projectRoot, "package.json");
+    return await readPackageMetadataFn(localPackagePath);
+  }
+  const projectPackagePath = join(projectRoot, "package.json");
+  const rootPackagePath = join(workspaceRoot, "package.json");
+  const metadata = await readPackageMetadataFn(rootPackagePath);
+  if (projectPackagePath !== rootPackagePath && existsSync(projectPackagePath)) {
+    const projectMetadata = await readPackageMetadataFn(projectPackagePath);
+    return mergePackageMetadataFn(metadata, projectMetadata);
+  } else {
+    return metadata;
+  }
+};
+const readRawPackageJson = async (packagePath) => {
+  try {
+    const content = await readFile(packagePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`Failed to read package.json from ${packagePath}:`, error);
+    throw error;
+  }
+};
+const mergeRawPackageJson = (parentPackage, childPackage) => {
+  const inheritableFields = [
+    "version",
+    "description",
+    "author",
+    "license",
+    "repository",
+    "keywords",
+    "homepage",
+    "bugs"
+  ];
+  const merged = { ...childPackage };
+  for (const field of inheritableFields) {
+    if (parentPackage[field] && !merged[field]) {
+      merged[field] = parentPackage[field];
+    }
+  }
+  return merged;
+};
+const resolvePackageMetadata = (projectRoot) => {
+  return resolvePackageMetadataT(projectRoot, readPackageMetadata, mergePackageMetadata);
+};
+const resolveRawPackageJson = (projectRoot) => {
+  return resolvePackageMetadataT(projectRoot, readRawPackageJson, mergeRawPackageJson);
+};
+export {
+  resolveRawPackageJson as a,
+  resolvePackageMetadata as r
+};

package/dist/internal.d.ts

@@ -19,30 +19,29 @@ export declare const findWorkspaceRoot: (startPath: string) => Promise<string |
  */
 export declare const mergePackageMetadata: (parentMetadata: PackageMetadata, childMetadata: PackageMetadata) => PackageMetadata;
 /**
- * Resolve package metadata for current project with workspace inheritance
- * @param projectRoot - Current project root
- * @returns Promise resolving to resolved package metadata
+ * Read and parse package.json file without flattening
+ * @param packagePath - Path to package.json
+ * @returns Promise resolving to raw package object
  */
-export declare const resolvePackageMetadata: (projectRoot: string) => Promise<PackageMetadata>;
+export declare const readRawPackageJson: (packagePath: string) => Promise<any>;
 /**
- * Generate banner string from package.json metadata
- * @param metadata - Package metadata
- * @param outputKeys - Array of keys to output in specified order
- * @returns Banner string
+ * Merge raw package.json objects with inheritance (child overrides parent)
+ * Only inherits package metadata fields, not project-specific configurations
+ * @param parentPackage - Parent package object
+ * @param childPackage - Child package object
+ * @returns Merged package object with only metadata fields
  */
-export declare const generateBanner: (metadata: PackageMetadata, outputKeys: string[]) => string;
+export declare const mergeRawPackageJson: (parentPackage: any, childPackage: any) => any;
 /**
- * Insert banner header at appropriate position considering shebang
- * @param content - The content to insert banner into
- * @param banner - The banner header to insert
- * @returns Content with banner header inserted
+ * Resolve package metadata for current project with workspace inheritance
+ * @param projectRoot - Current project root
+ * @returns Promise resolving to resolved package metadata
  */
-export declare const insertBannerHeader: (content: string, banner: string) => string;
+export declare const resolvePackageMetadata: (projectRoot: string) => Promise<PackageMetadata>;
 /**
- * Generate TypeScript metadata file content from package metadata
- * @param metadata - Package metadata
- * @param outputKeys - Array of keys to output
- * @returns TypeScript file content
+ * Resolve raw package.json for current project with workspace inheritance
+ * @param projectRoot - Current project root
+ * @returns Promise resolving to resolved raw package.json object
  */
-export declare const generateMetadataFile: (metadata: PackageMetadata, outputKeys: string[]) => string;
+export declare const resolveRawPackageJson: (projectRoot: string) => Promise<any>;
 //# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AA2BrD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,eAAe,CAWtF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAU,WAAW,MAAM,KAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CA0BrF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,gBAAgB,eAAe,EAC/B,eAAe,eAAe,KAC7B,eAoBF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,eAAe,CAsBzF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,eAAe,EAAE,YAAY,MAAM,EAAE,KAAG,MAWhF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,EAAE,QAAQ,MAAM,KAAG,MAWpE,CAAC;AAYF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,UAAU,eAAe,EAAE,YAAY,MAAM,EAAE,KAAG,MAmBtF,CAAC"}
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AA2BrD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,eAAe,CAWtF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAU,WAAW,MAAM,KAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CA0BrF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC/B,gBAAgB,eAAe,EAC/B,eAAe,eAAe,KAC7B,eAoBF,CAAC;AAqCF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,GAAG,CAQzE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,eAAe,GAAG,EAAE,cAAc,GAAG,KAAG,GAwB3E,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GAAI,aAAa,MAAM,KAAG,OAAO,CAAC,eAAe,CAEnF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAI,aAAa,MAAM,KAAG,OAAO,CAAC,GAAG,CAEtE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screw-up",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "description": "Simply package metadata inserter on Vite plugin",
   "keywords": [
     "vite",
@@ -27,20 +27,28 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "bin": {
+    "screw-up": "./dist/cli.js"
+  },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "rv --npm . && tsc --noEmit && vite build && tsc --emitDeclarationOnly --outDir dist",
-    "test": "rv --npm . && tsc --noEmit && vitest run"
+    "build": "rv --npm . && npm i && vite build",
+    "test": "rv --npm . && npm i && npm run build && vitest run"
   },
   "peerDependencies": {
+    "glob": ">=11.0.0",
+    "tar-stream": ">=3.0.0",
     "vite": ">=5.0.0"
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.0.0",
-    "vite-plugin-dts": "^3.0.0",
-    "vitest": "^1.0.0"
+    "@types/node": ">=20.0.0",
+    "@types/tar-stream": "^3.1.4",
+    "dayjs": "^1.11.13",
+    "tar": ">=7.4.0",
+    "typescript": ">=5.0.0",
+    "vite-plugin-dts": ">=3.0.0",
+    "vitest": ">=1.0.0"
   }
 }