@somewhatabstract/x 0.0.1 → 0.1.1

package/README.md

@@ -1,2 +1,105 @@
 # x
- Execute any bin defined by any package in a monorepo without needing to install that package
+
+Execute any bin defined by any package within a monorepo without needing to install that package at the root.
+
+## Overview
+
+`x` is a tool for monorepos that allows you to execute binary scripts from any package in your workspace without installing them globally or in your current package. It automatically discovers all packages in your workspace and finds the matching bin script.
+
+**Supports multiple package managers:**
+
+- 📦 npm workspaces
+- 🧶 Yarn (classic and modern)
+- 📌 pnpm workspaces
+- 🎯 Lerna
+- 🍞 Bun workspaces
+- 🚀 Rush
+
+## Installation
+
+```bash
+npm install -g @somewhatabstract/x
+# or
+pnpm add -g @somewhatabstract/x
+# or
+yarn global add @somewhatabstract/x
+```
+
+## Usage
+
+```bash
+# Execute a bin script from any package in the workspace
+x <script-name> [-- <args...>]
+
+# Preview what would be executed (dry-run mode)
+x --dry-run <script-name>
+
+# Pass arguments to the script (use `--` when args might look like x's own options)
+x my-script -- --flag value
+```
+
+This only executes bin scripts defined by packages in your workspace, not their dependencies. The bin must be an executable file with a shebang (on Unix-like systems) or a directly runnable file (on Windows), or a JS script that can be executed with Node.js.
+
+## Features
+
+- 🔍 **Automatic Discovery**: Finds all packages in your monorepo workspace
+- 🎯 **Smart Matching**: Locates the bin script you want to run
+- 🚀 **No Installation Needed**: Execute bins without installing packages
+- 👁️ **Dry-Run Mode**: Preview what would be executed with `--dry-run`
+- 🔧 **Multi-Language Support**: Works with any executable script (Node.js, Bash, Python, etc.)
+- 📦 **Multi-Package-Manager**: Works with npm, Yarn, pnpm, Lerna, Bun, and Rush
+- ⚡ **Fast**: Efficient package discovery using @manypkg
+- 🛡️ **Type-Safe**: Written in TypeScript with full type safety
+
+## How It Works
+
+1. **Workspace Detection**: Uses `@manypkg/find-root` to find the workspace root (supports npm, Yarn, pnpm, Lerna, Bun, Rush)
+2. **Package Discovery**: Uses `@manypkg/get-packages` to discover all packages in the workspace
+3. **Bin Matching**: Searches through package.json files to find bins matching your requested script name
+4. **Execution**: Executes the matched script either directly via the OS or via Node.js:
+   - **Direct OS execution**: On Unix-like systems this requires an executable file with a shebang; on Windows the bin must be a directly runnable file such as a `.exe`, `.cmd`, or `.bat`.
+   - **Node.js execution**: If the bin is a JS file, it is executed with Node.js.
+
+## Requirements
+
+- Node.js >= 20
+- A monorepo workspace (npm, Yarn, pnpm, Lerna, Bun, or Rush)
+
+## CLI Options
+
+- `<script-name>` - Name of the bin script to execute (required)
+- `[args...]` - Arguments to pass to the script (optional)
+- `-d, --dry-run` - Show what would be executed without running it
+- `-h, --help` - Show help
+- `-v, --version` - Show version
+
+## Error Handling
+
+The tool provides clear, user-friendly error messages:
+
+- **Not in a workspace**: "Could not find workspace root. Make sure you're in a monorepo workspace."
+- **Script not found**: "No bin script named '<name>' found in any workspace package."
+- **Ambiguous match**: Lists all packages that provide the bin and asks you to be more specific
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Run tests
+pnpm test
+
+# Type check
+pnpm typecheck
+
+# Build
+pnpm build
+
+# Run locally
+./dist/x.mjs <script-name>
+```
+
+## License
+
+MIT

package/dist/x.mjs

@@ -1,12 +1,287 @@
 #!/usr/bin/env node
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { getPackages } from "@manypkg/get-packages";
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as path$1 from "node:path";
+import path from "node:path";
+import { findRoot } from "@manypkg/find-root";
+
+//#region src/errors.ts
+/**
+* Error class for known/expected errors that should be displayed to the user
+* without a stack trace.
+*/
+var HandledError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "HandledError";
+	}
+};
+
+//#endregion
+//#region src/discover-packages.ts
+/**
+* Discover all packages in the workspace using @manypkg/get-packages.
+* Supports multiple package managers: npm, yarn, pnpm, lerna, bun, rush.
+*
+* @param workspaceRoot - The absolute path to the workspace root
+* @returns Array of package information
+* @throws {HandledError} If package discovery fails
+*/
+async function discoverPackages(workspaceRoot) {
+	try {
+		return (await getPackages(workspaceRoot)).packages.map((pkg) => ({
+			name: pkg.packageJson.name,
+			path: pkg.dir,
+			version: pkg.packageJson.version || "unknown"
+		}));
+	} catch (error) {
+		if (error instanceof HandledError) throw error;
+		throw new HandledError(`Failed to discover packages`, { cause: error });
+	}
+}
+
+//#endregion
+//#region src/build-environment.ts
+/**
+* Build environment variables for script execution that mimics npm/pnpm behavior.
+* The environment is set as if the package were installed at the workspace root.
+*
+* @param workspaceRoot - Path to the workspace root
+* @param currentEnv - Current environment variables (usually process.env)
+* @returns Environment object to pass to child_process.spawn
+*/
+async function buildEnvironment(workspaceRoot, currentEnv) {
+	let workspacePackageJson = {};
+	try {
+		const packageJsonPath = path$1.join(workspaceRoot, "package.json");
+		const content = await fs.readFile(packageJsonPath, "utf-8");
+		workspacePackageJson = JSON.parse(content);
+	} catch {}
+	let ourPackageVersion = "0.0.0-development";
+	try {
+		const ownPackageJsonPath = path$1.join(__dirname, "..", "package.json");
+		const ownPackageJsonContent = await fs.readFile(ownPackageJsonPath, "utf-8");
+		const ownPackageJson = JSON.parse(ownPackageJsonContent);
+		if (typeof ownPackageJson.version === "string") ourPackageVersion = ownPackageJson.version;
+	} catch {}
+	const env = {
+		...currentEnv,
+		PATH: [path$1.join(workspaceRoot, "node_modules", ".bin"), currentEnv.PATH].filter(Boolean).join(path$1.delimiter),
+		npm_command: "exec",
+		npm_execpath: process.execPath,
+		npm_node_execpath: process.execPath,
+		NODE: process.execPath,
+		INIT_CWD: process.cwd(),
+		npm_config_user_agent: `x/${ourPackageVersion} node/${process.version} ${process.platform} ${process.arch}`
+	};
+	if (workspacePackageJson.name) env.npm_package_name = workspacePackageJson.name;
+	if (workspacePackageJson.version) env.npm_package_version = workspacePackageJson.version;
+	if (workspacePackageJson.description) env.npm_package_description = workspacePackageJson.description;
+	for (const field of [
+		"author",
+		"license",
+		"homepage",
+		"repository",
+		"bugs",
+		"keywords"
+	]) if (workspacePackageJson[field]) {
+		const value = workspacePackageJson[field];
+		env[`npm_package_${field}`] = typeof value === "string" ? value : JSON.stringify(value);
+	}
+	return env;
+}
+
+//#endregion
+//#region src/is-node-executable.ts
+/**
+* Determine if a bin file should be invoked via the Node executable,
+* based on its file extension (case-insensitive).
+* Matches npm's behavior for .js, .mjs, and .cjs files.
+*
+* @param binPath - The path to the bin file
+* @returns True if the file should be invoked via node
+*/
+function isNodeExecutable(binPath) {
+	const lower = binPath.toLowerCase();
+	return lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".cjs");
+}
+
+//#endregion
+//#region src/execute-script.ts
+/**
+* Execute a bin script with the given arguments.
+* Executes the script as if the package were installed at the workspace root,
+* with npm/pnpm-style environment variables.
+*
+* @param bin - The bin info to execute
+* @param args - Arguments to pass to the script
+* @param workspaceRoot - Path to the workspace root
+* @returns A promise that resolves with the exit code
+*/
+async function executeScript(bin, args, workspaceRoot) {
+	const env = await buildEnvironment(workspaceRoot, process.env);
+	const [executable, spawnArgs] = isNodeExecutable(bin.binPath) ? [process.execPath, [bin.binPath, ...args]] : [bin.binPath, args];
+	return new Promise((resolve) => {
+		const child = spawn(executable, spawnArgs, {
+			stdio: "inherit",
+			env
+		});
+		child.on("error", (_) => {
+			resolve(1);
+		});
+		child.on("exit", (code, signal) => {
+			if (signal) resolve(1);
+			else resolve(code ?? 1);
+		});
+	});
+}
+
+//#endregion
+//#region src/resolve-bin-path.ts
+/**
+* Resolve a bin script to the actual file path.
+*
+* This function ensures that the resolved bin path is within the package
+* directory to prevent path traversal issues.
+*
+* @param pkg - The package information containing the path to the package
+* @param bin - The bin entry from package.json, which can be a string or an
+* object
+* @param binName - The name of the bin as specified in package.json
+* @returns The resolved absolute path to the bin script, or null if invalid
+
+*/
+function resolveBinPath(pkg, bin, binName) {
+	const binPath = !bin ? null : typeof bin === "string" && pkg.name === binName ? bin : typeof bin === "object" && bin[binName] ? bin[binName] : null;
+	if (!binPath) return null;
+	const packageDir = path.resolve(pkg.path);
+	const resolvedBinPath = path.resolve(pkg.path, binPath);
+	if (resolvedBinPath !== packageDir && !resolvedBinPath.startsWith(packageDir + path.sep)) return null;
+	return resolvedBinPath;
+}
+
+//#endregion
+//#region src/find-matching-bins.ts
+/**
+* Find all packages that have a bin script matching the given name.
+*
+* @param packages - List of packages from discoverPackages
+* @param binName - Name of the bin script to find
+* @returns Array of matching bin information
+*/
+async function findMatchingBins(packages, binName) {
+	const matches = [];
+	for (const pkg of packages) try {
+		const packageJsonPath = path$1.join(pkg.path, "package.json");
+		const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+		const bin = JSON.parse(packageJsonContent).bin;
+		const resolvedBinPath = resolveBinPath(pkg, bin, binName);
+		if (!resolvedBinPath) continue;
+		matches.push({
+			packageName: pkg.name,
+			packagePath: pkg.path,
+			binName,
+			binPath: resolvedBinPath
+		});
+	} catch (error) {
+		if (error instanceof SyntaxError) console.warn(`Warning: Failed to parse package.json for package "${pkg.name}" at "${pkg.path}": invalid JSON.`);
+		else if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {} else console.warn(`Warning: Could not read package.json for package "${pkg.name}" at "${pkg.path}":`, error);
+	}
+	return matches;
+}
+
+//#endregion
+//#region src/find-workspace-root.ts
+/**
+* Find the workspace root using @manypkg/find-root.
+* Supports multiple package managers: npm, yarn, pnpm, lerna, bun, rush.
+*
+* @param startDir - Directory to start searching from (defaults to cwd)
+* @returns The absolute path to the workspace root
+* @throws {HandledError} If workspace root cannot be found
+*/
+async function findWorkspaceRoot(startDir = process.cwd()) {
+	try {
+		return (await findRoot(startDir)).rootDir;
+	} catch (error) {
+		throw new HandledError("Could not find workspace root. Make sure you're in a monorepo workspace.", { cause: error });
+	}
+}
+
+//#endregion
 //#region src/x-impl.ts
-function xImpl() {
-	console.log("Hello, world!");
+/**
+* Main implementation of the x command.
+* Finds and executes a bin script from any package in the workspace.
+*
+* @param scriptName - Name of the bin script to execute
+* @param args - Arguments to pass to the script
+* @param options - Additional options
+* @returns Result object with exit code
+*/
+async function xImpl(scriptName, args = [], options = {}) {
+	try {
+		if (!scriptName || !scriptName.trim()) throw new HandledError("Script name cannot be empty");
+		if (scriptName.includes("/") || scriptName.includes("\\")) throw new HandledError("Script name cannot contain path separators");
+		const workspaceRoot = await findWorkspaceRoot();
+		const packages = await discoverPackages(workspaceRoot);
+		if (packages.length === 0) throw new HandledError("No packages found in workspace. Is this a valid monorepo?");
+		const matchingBins = await findMatchingBins(packages, scriptName);
+		if (matchingBins.length === 0) throw new HandledError(`No bin script named "${scriptName}" found in any workspace package.`);
+		if (matchingBins.length > 1) {
+			console.error(`Multiple packages provide bin "${scriptName}". Please be more specific.`);
+			console.error("\nMatching packages:");
+			matchingBins.forEach((bin) => {
+				console.error(`  - ${bin.packageName} (${bin.packagePath})`);
+			});
+			throw new HandledError(`Ambiguous bin name "${scriptName}". Found ${matchingBins.length} matches.`);
+		}
+		const bin = matchingBins[0];
+		if (options.dryRun) {
+			console.log(`Would execute: ${bin.binName} from ${bin.packageName}`);
+			console.log(`  Binary: ${bin.binPath}`);
+			console.log(`  Arguments: ${args.join(" ")}`);
+			return { exitCode: 0 };
+		}
+		return { exitCode: await executeScript(bin, args, workspaceRoot) };
+	} catch (error) {
+		if (error instanceof HandledError) {
+			console.error(`Error: ${error.message}`);
+			return { exitCode: 1 };
+		}
+		throw error;
+	}
 }
 
 //#endregion
 //#region src/bin/x.ts
-xImpl();
+const argv = yargs(hideBin(process.argv)).usage("Usage: $0 <script-name> [...args]").command("$0 <script-name> [args..]", "Execute a bin script from any package in the workspace", (yargs) => {
+	return yargs.positional("script-name", {
+		describe: "Name of the bin script to execute",
+		type: "string",
+		demandOption: true
+	}).positional("args", {
+		describe: "Arguments to pass to the script",
+		type: "string",
+		array: true,
+		default: []
+	});
+}).option("dry-run", {
+	alias: "d",
+	describe: "Show what would be executed without running it",
+	type: "boolean",
+	default: false
+}).help().alias("help", "h").version().alias("version", "v").example("$0 tsc --noEmit", "Run TypeScript compiler from any package").example("$0 eslint src/", "Run ESLint from any package that provides it").example("$0 --dry-run jest", "Preview which jest would be executed").strict().parseSync();
+const scriptName = argv["script-name"];
+xImpl(scriptName, argv._ || [], { dryRun: argv["dry-run"] }).then((result) => {
+	process.exit(result.exitCode);
+}).catch((error) => {
+	console.error("Unexpected error:", error);
+	process.exit(1);
+});
 
 //#endregion
 export {  };

package/package.json

@@ -2,12 +2,17 @@
   "name": "@somewhatabstract/x",
   "private": false,
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "bin": {
     "x": "./dist/x.mjs"
   },
-  "version": "0.0.1",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "version": "0.1.1",
   "description": "Execute any bin defined by any package in a monorepo without needing to install that package",
   "bugs": {
     "url": "https://github.com/somewhatabstract/x/issues"
@@ -22,18 +27,26 @@
     "yarn": "please-use-pnpm"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.4.3",
     "@changesets/cli": "^2.29.8",
     "@codecov/rollup-plugin": "^1.9.1",
     "@types/node": "^20.19.29",
+    "@types/yargs": "^17.0.35",
     "@vitest/coverage-v8": "^4.0.17",
-    "tsdown": "0.20.0-beta.3",
+    "tsdown": "0.20.3",
     "typescript": "^5.9.3",
     "vitest": "^4.0.17"
   },
+  "dependencies": {
+    "@manypkg/find-root": "^3.1.0",
+    "@manypkg/get-packages": "^3.1.0",
+    "yargs": "^18.0.0"
+  },
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
-    "lint": "echo \"No linting configured\"",
+    "lint": "biome check",
+    "lint:fix": "biome check --write --unsafe",
     "typecheck": "tsc --noEmit --project tsconfig.json",
     "typewatch": "pnpm typecheck --watch",
     "test": "vitest",

package/.changeset/README.md

@@ -1,8 +0,0 @@
-# Changesets
-
-Hello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that works
-with multi-package repos, or single-package repos to help you version and publish your code. You can
-find the full documentation for it [in our repository](https://github.com/changesets/changesets)
-
-We have a quick list of common questions to get you started engaging with this project in
-[our documentation](https://github.com/changesets/changesets/blob/main/docs/common-questions.md)

package/.changeset/config.json

@@ -1,11 +0,0 @@
-{
-    "$schema": "https://unpkg.com/@changesets/config@3.1.1/schema.json",
-    "changelog": "@changesets/cli/changelog",
-    "commit": false,
-    "fixed": [],
-    "linked": [],
-    "access": "restricted",
-    "baseBranch": "main",
-    "updateInternalDependencies": "patch",
-    "ignore": []
-}

package/.github/codeql/codeql-config.yml

@@ -1,5 +0,0 @@
-name: X CodeQL config
-paths:
-  - "src"
-paths-ignore:
-  - src/__tests__

package/.github/workflows/codeql-analysis.yml

@@ -1,71 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ main ]
-  schedule:
-    - cron: '16 7 * * 2'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'javascript' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
-        # Learn more:
-        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v5
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v4
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        # queries: ./path/to/local/query, your-org/your-repo/queries@main
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v4
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 https://git.io/JvXDl
-
-    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-    #    and modify them (or add more) to build your code if your project
-    #    uses a compiled language
-
-    #- run: |
-    #   make bootstrap
-    #   make release
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v4

package/.github/workflows/nodejs.yml

@@ -1,131 +0,0 @@
-name: Node CI
-
-on:
-  pull_request:
-    # ready_for_review is useful for when a PR is converted from "draft" to "not
-    # draft".
-    types: [edited, opened, synchronize, ready_for_review, reopened]
-
-  push:
-    branches:
-    - main
-
-jobs:
-  lint:
-    name: Lint and static types check
-    env:
-      CI: true
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        node-version: [20.x]
-    steps:
-    - uses: actions/checkout@v4
-
-    - uses: pnpm/action-setup@v4
-      name: Install pnpm
-      with:
-        run_install: false
-        package_json_file: 'package.json'
-
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v4
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'pnpm'
-        cache-dependency-path: 'pnpm-lock.yaml'
-
-    - name: Install Dependencies
-      shell: bash
-      run: pnpm install --frozen-lockfile
-
-    - name: Lint
-      run: pnpm lint
-
-    - name: Static Types
-      run: pnpm typecheck
-
-    - name: Changesets check
-      uses: Khan/actions@check-for-changeset-v1
-      if: |
-        github.actor != 'dependabot[bot]' &&
-        github.actor != 'dependabot-preview[bot]' &&
-        github.event_name == 'pull_request'
-      with:
-        exclude: .github/,.storybook/
-
-
-  coverage:
-    name: Update test coverage
-    env:
-      CI: true
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        node-version: [20.x]
-    steps:
-    - uses: actions/checkout@v4
-
-    - uses: pnpm/action-setup@v4
-      name: Install pnpm
-      with:
-        run_install: false
-        package_json_file: 'package.json'
-
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v4
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'pnpm'
-        cache-dependency-path: 'pnpm-lock.yaml'
-
-    - name: Install Dependencies
-      shell: bash
-      run: pnpm install --frozen-lockfile
-
-    - name: Run tests with coverage
-      run: pnpm coverage
-    - name: Upload coverage
-      uses: codecov/codecov-action@v5
-      env:
-        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-
-
-  build:
-    needs: [coverage, lint]
-    name: Build
-    env:
-      CI: true
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        node-version: [20.x]
-    steps:
-    - uses: actions/checkout@v4
-
-    - uses: pnpm/action-setup@v4
-      name: Install pnpm
-      with:
-        run_install: false
-        package_json_file: 'package.json'
-
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v4
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'pnpm'
-        cache-dependency-path: 'pnpm-lock.yaml'
-
-    - name: Install Dependencies
-      shell: bash
-      run: pnpm install --frozen-lockfile
-
-    - name: Run build
-      env:
-        # We only want to upload bundle analysis for a PR once,
-        # so we only provide a token for the ubuntu-latest job.
-        CODECOV_TOKEN: ${{ matrix.os == 'ubuntu-latest' && secrets.CODECOV_TOKEN || '' }}
-      run: pnpm build

package/.github/workflows/release.yml

@@ -1,98 +0,0 @@
-name: Release
-
-on:
-  push:
-    branches:
-      - main
-
-# This workflow will run changesets depending on two different scenarios:
-#
-# 1. If we are landing a specific commit into main (Author PR), then
-#    changesets will check if there are changes verifying the Markdown files
-#    generated automatically:
-#
-#    a) There are new versions and there's NO Release PR, then the changesets
-#    action will create a new Release PR.
-#
-#    b) There's a Release PR, then the changesets action will update the
-#    existing Release PR with the new commit.
-#
-#    NOTE: (in both cases, changesets will modify the new version in
-#    package.json for each package, and will remove the MD files as part of the
-#    Release PR).
-#
-# 2. If we are landing the Release PR into main, then the changesets action
-#    will publish the changes to npm.
-#
-# For more info about this workflow, see:
-# https://github.com/changesets/action#usage
-jobs:
-  release:
-    name: Release
-    runs-on: ubuntu-latest
-    permissions:
-      id-token: write # For provenance and trusted publishing
-      contents: write # For creating release PRs
-      pull-requests: write # For creating release PRs
-    steps:
-      - uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-          persist-credentials: false
-
-      - uses: pnpm/action-setup@v4
-        name: Install pnpm
-        with:
-          run_install: false
-          package_json_file: package.json
-
-      - name: Use Node.js 20.x
-        uses: actions/setup-node@v6
-        with:
-          node-version: 20.x
-          cache: pnpm
-          cache-dependency-path: pnpm-lock.yaml
-
-      - name: Install Dependencies
-        shell: bash
-        run: pnpm install --frozen-lockfile
-
-      - name: ⬆️ Upgrade npm for OIDC support
-        shell: bash
-        run: |
-          # npm trusted publishing requires npm CLI v11.5.1+
-          # Node.js 20 shipped with npm 9.x, so we likely need to upgrade
-
-          # First, let's check the current npm version, and if it's already
-          # sufficient, we can skip the upgrade step.
-          CURRENT_NPM_VERSION=$(npm --version)
-          REQUIRED_NPM_VERSION="11.5.1"
-
-          # This sorts the version numbers using `sort -V` and then takes
-          # the lowest version.
-          LOWEST_NPM_VERSION=$(printf '%s\n' "$REQUIRED_NPM_VERSION" "$CURRENT_NPM_VERSION" | sort -V | head -n1)
-
-          # If the lowest version is the same as the required version, then we
-          # don't need to upgrade as that means our current version is newer.
-          if [ "$LOWEST_NPM_VERSION" = "$REQUIRED_NPM_VERSION" ]; then
-            echo "✅ npm is already at version $CURRENT_NPM_VERSION"
-          else
-            npm install -g npm@latest && echo "✅ npm upgraded to $(npm --version)"
-          fi
-
-      - name: Create Release Pull Request or Publish to npm
-        id: changesets
-        uses: changesets/action@v1
-        with:
-          publish: pnpm publish:ci
-        env:
-          # We use a Personal Access Token here rather than the GITHUB_TOKEN
-          # so that it will trigger our other actions. The token has to be on
-          # the account of someone with appropriate access levels and given the
-          # repo scope.
-          GITHUB_TOKEN: ${{ secrets.BOT_PA_TOKEN }}
-          # This is the token used to publish to npm when OIDC trusted
-          # publishing isn't yet setup
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-          # This is used for the bundle analysis
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

package/CODE_OF_CONDUCT.md

@@ -1,76 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, sex characteristics, gender identity and expression,
-level of experience, education, socio-economic status, nationality, personal
-appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
- advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
- address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
- professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at jeff[at]somewhatabstract[dot]com. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see
-https://www.contributor-covenant.org/faq

package/CONTRIBUTING.md

@@ -1,70 +0,0 @@
-# Contributing to `x`
-
-🙇Thank you for your interest in contributing to this 📦.
-
-Whether raising an issue, reviewing a pull request, or implementing a change, the participation of others is a wonderful 🎁. Read on to find out how you can get involved.
-
-📖 Be sure to read our [Code of Conduct](CODE_OF_CONDUCT.md).
-
-## 🛑 Bugs And Feature Requests
-
-If you find a bug or want to make enhancements to the project, head on over to the [🔗Issues](https://github.com/somewhatabstract/x/issues) section and raise an issue. The issue templates will guide you in providing details that will help others help you.
-
-## 💻 Code Changes
-
-### ⓵ Making your first change
-
-Look for bugs or feature requests with the [good first issue](https://github.com/somewhatabstract/x/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) or [help wanted](https://github.com/somewhatabstract/x/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22+) labels and have a go at implementing a change. Once your change is ready, you can submit a pull request.
-
-### 🎬 Getting Started
-
-To work in the `x` repository, follow these steps:
-
-1. Clone the repository
-   - `gh repo clone somewhatabstract/x`
-   - -or-
-   - `git clone git@github.com:somewhatabstract/x.git`
-2. Install `pnpm`
-   - `corepack enable pnpm`
-   - `corepack prepare pnpm --activate`
-3. Run `pnpm install` to install the dependencies
-
-You can now work on `x`. We prefer [🔗Visual Studio Code](https://code.visualstudio.com/) as our development environment (it's cross-platform and awesome), but please use what you feel comfortable with (we'll even forgive you for using vim).
-
-### 🧪 Code Quality
-
-#### Manual
-
-We love code reviews. If there are open pull requests, please feel free to review them and provide feedback. Feedback is a gift and code reviews are often a bottleneck in getting new things released. Jump in, even if you don't know anything; you probably know more than you think.
-
-💭**REMEMBER** Be kind and considerate. Folks are volunteering their time and code reviews are a moment of vulnerability where a criticism of the code can easily become a criticism of the individual that wrote it.
-
-1. Take your time
-2. Consider how you might receive the feedback you are giving if it were attached to code you wrote
-3. Favor asking questions over prescribing solutions.
-
-#### Automated
-
-To ensure code quality, we use TypeScript, biome, and vitest. These are all executed when you submit a pull request to ensure contributions meet our code quality standards.
-
-To execute these operations outside of a pull request, you can use `pnpm`.
-
-- `pnpm typecheck`
-- `pnpm lint`
-- `pnpm test`
-
-If you make changes that change snapshots, you may need to run tests with the `-u` vitest option and commit the updated snapshot files along with the rest of your contribution.
-
-💭**REMEMBER** If you would like to contribute code changes to the project, first make sure there's a corresponding issue for the change you wish to make.
-
-## 📦 Build And Publish
-
-Anyone can create a local build of the distributed code by running `pnpm build`.
-
-Running the build will execute tests first.
-
-### Publishing
-
-Publishing is automated through our use of [changesets][1]. When a PR is merged, a release PR is created that bundles all the changes since the last release. This PR is then merged and the changeset is published to npm.
-
-[1]:https://github.com/changesets/changesets/blob/main/README.md#documentation

package/src/__tests__/x-impl.test.ts

@@ -1,15 +0,0 @@
-import {describe, expect, it, vi} from "vitest";
-import { xImpl } from "../x-impl";
-
-describe("xImpl", () => {
-    it("should log 'Hello, world!'", () => {
-        // Arrange
-        const consoleSpy = vi.spyOn(console, "log");
-
-        // Act
-        xImpl();
-
-        // Assert
-        expect(consoleSpy).toHaveBeenCalledWith("Hello, world!");
-    });
-});

package/src/bin/x.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-import {xImpl} from "../x-impl";
-xImpl();

package/src/x-impl.ts

@@ -1,5 +0,0 @@
-
-export function xImpl(): void {
-    const x: string = "Hello, world!";
-    console.log(x);
-};

package/tsconfig-types.json

@@ -1,7 +0,0 @@
-/* Visit https://aka.ms/tsconfig to read more about this file */
-{
-    "extends": "./tsconfig.json",
-    "exclude": [
-        "**/*.test.ts",
-    ],
-}

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "esnext",
-        "lib": [
-            "es2023"
-        ],
-        "moduleDetection": "force",
-        "module": "preserve",
-        "moduleResolution": "bundler",
-        "resolveJsonModule": true,
-        "types": [
-            "node"
-        ],
-        "typeRoots": [
-            "./node_modules/@types"
-        ],
-        "strict": true,
-        "noUnusedLocals": true,
-        "declaration": true,
-        "emitDeclarationOnly": true,
-        "esModuleInterop": true,
-        "isolatedModules": true,
-        "verbatimModuleSyntax": true,
-        "skipLibCheck": true
-    },
-    "include": [
-        "src"
-    ]
-}

package/tsdown.config.ts

@@ -1,24 +0,0 @@
-import {codecovRollupPlugin} from "@codecov/rollup-plugin";
-import {defineConfig} from "tsdown";
-
-export default defineConfig({
-    entry: ["./src/bin/x.ts"],
-    platform: "node",
-    sourcemap: false,
-    dts: {
-        oxc: true,
-        tsconfig: "tsconfig-types.json"
-    },
-    plugins: [
-        process.env.CODECOV_TOKEN
-            ? // This plugin provides bundle analysis from codecov, but does
-              // not work locally without additional config, and it does not
-              // output size info to the console.
-              codecovRollupPlugin({
-                  enableBundleAnalysis: true, // true when CODECOV_TOKEN set
-                  bundleName: "x",
-                  uploadToken: process.env.CODECOV_TOKEN,
-              })
-            : undefined,
-    ],
-});

package/vitest.config.ts

@@ -1,9 +0,0 @@
-import {defineConfig} from "vitest/config";
-
-export default defineConfig({
-    test: {
-        coverage: {
-            reporter: ["text", "json"],
-        },
-    },
-});