screw-up 0.7.1 → 0.9.1

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) {
@@ -100,20 +23,57 @@ const insertBannerHeader = (content, banner) => {
     return banner + "\n" + content;
   }
 };
+const sanitizeKey = (key) => {
+  return key.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^(\d)/, "_$1");
+};
+const generateMetadataFile = (metadata, outputKeys) => {
+  const lines = [];
+  lines.push("// This file is auto-generated by screw-up plugin");
+  lines.push("// Do not edit manually");
+  lines.push("");
+  for (const key of outputKeys) {
+    const value = metadata[key];
+    if (value) {
+      const sanitizedKey = sanitizeKey(key);
+      const escapedValue = JSON.stringify(value);
+      lines.push(`export const ${sanitizedKey} = ${escapedValue};`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+};
 const screwUp = (options = {}) => {
   const {
     outputKeys = ["name", "version", "description", "author", "license", "repository.url"],
-    assetFilters = ["\\.d\\.ts$"]
+    assetFilters = ["\\.d\\.ts$"],
+    outputMetadataFile = false,
+    outputMetadataFilePath = "src/generated/packageMetadata.ts",
+    outputMetadataKeys = ["name", "version", "description", "author", "license", "repository.url"]
   } = options;
   const assetFiltersRegex = assetFilters.map((filter) => new RegExp(filter));
   let banner;
+  let metadata;
+  let projectRoot;
   return {
     name: "screw-up",
     apply: "build",
     async configResolved(config) {
-      const metadata = await resolvePackageMetadata(config.root);
+      projectRoot = config.root;
+      metadata = await internal.resolvePackageMetadata(config.root);
       banner = generateBanner(metadata, outputKeys);
     },
+    async buildStart() {
+      if (outputMetadataFile) {
+        const metadataContent = generateMetadataFile(metadata, outputMetadataKeys);
+        const metadataPath = path.join(projectRoot, outputMetadataFilePath);
+        try {
+          await promises.mkdir(path.dirname(metadataPath), { recursive: true });
+          await promises.writeFile(metadataPath, metadataContent);
+        } catch (error) {
+          console.warn(`Failed to write metadata file to ${metadataPath}:`, error);
+        }
+      }
+    },
     generateBundle(_options, bundle) {
       for (const fileName in bundle) {
         const chunk = bundle[fileName];
@@ -147,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
  */
@@ -14,6 +22,21 @@ export interface ScrewUpOptions {
      * @default ['\.d\.ts$']
      */
     assetFilters?: string[];
+    /**
+     * Enable TypeScript metadata file generation
+     * @default false
+     */
+    outputMetadataFile?: boolean;
+    /**
+     * Output path for TypeScript metadata file
+     * @default 'src/generated/packageMetadata.ts'
+     */
+    outputMetadataFilePath?: string;
+    /**
+     * Array of keys to output in metadata file in the specified order
+     * @default ['name', 'version', 'description', 'author', 'license', 'repository.url']
+     */
+    outputMetadataKeys?: string[];
 }
 /**
  * Vite plugin that adds banner to the bundled code

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;CACzB;AAED;;;;GAIG;AACH,QAAA,MAAM,OAAO,GAAI,UAAS,cAAmB,KAAG,MA2D/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 } 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) {
@@ -99,20 +21,57 @@ const insertBannerHeader = (content, banner) => {
     return banner + "\n" + content;
   }
 };
+const sanitizeKey = (key) => {
+  return key.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^(\d)/, "_$1");
+};
+const generateMetadataFile = (metadata, outputKeys) => {
+  const lines = [];
+  lines.push("// This file is auto-generated by screw-up plugin");
+  lines.push("// Do not edit manually");
+  lines.push("");
+  for (const key of outputKeys) {
+    const value = metadata[key];
+    if (value) {
+      const sanitizedKey = sanitizeKey(key);
+      const escapedValue = JSON.stringify(value);
+      lines.push(`export const ${sanitizedKey} = ${escapedValue};`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+};
 const screwUp = (options = {}) => {
   const {
     outputKeys = ["name", "version", "description", "author", "license", "repository.url"],
-    assetFilters = ["\\.d\\.ts$"]
+    assetFilters = ["\\.d\\.ts$"],
+    outputMetadataFile = false,
+    outputMetadataFilePath = "src/generated/packageMetadata.ts",
+    outputMetadataKeys = ["name", "version", "description", "author", "license", "repository.url"]
   } = options;
   const assetFiltersRegex = assetFilters.map((filter) => new RegExp(filter));
   let banner;
+  let metadata;
+  let projectRoot;
   return {
     name: "screw-up",
     apply: "build",
     async configResolved(config) {
-      const metadata = await resolvePackageMetadata(config.root);
+      projectRoot = config.root;
+      metadata = await resolvePackageMetadata(config.root);
       banner = generateBanner(metadata, outputKeys);
     },
+    async buildStart() {
+      if (outputMetadataFile) {
+        const metadataContent = generateMetadataFile(metadata, outputMetadataKeys);
+        const metadataPath = join(projectRoot, outputMetadataFilePath);
+        try {
+          await mkdir(dirname(metadataPath), { recursive: true });
+          await writeFile(metadataPath, metadataContent);
+        } catch (error) {
+          console.warn(`Failed to write metadata file to ${metadataPath}:`, error);
+        }
+      }
+    },
     generateBundle(_options, bundle) {
       for (const fileName in bundle) {
         const chunk = bundle[fileName];
@@ -147,5 +106,6 @@ const screwUp = (options = {}) => {
   };
 };
 export {
-  screwUp as default
+  screwUp as default,
+  generateBanner
 };