@konvert7/klint 0.10.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konvert7/klint",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Architecture-as-Code linter for TypeScript. Enforce layer boundaries, import rules, and singleton patterns in YAML.",
   "type": "module",
   "bin": {
@@ -39,6 +39,7 @@
     "pack:check": "bun tests/pack-check.ts",
     "native:stage": "bun tests/stage-native-binary.ts",
     "native:smoke": "bun tests/smoke-native-binary.ts",
+    "native:release:dry-run": "bun tools/prepare-native-release.ts --version 0.0.0-dry-run",
     "check": "biome check",
     "check-write": "biome check --write",
     "knip": "knip-bun",
@@ -59,6 +60,12 @@
     "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },
+  "optionalDependencies": {
+    "@konvert7/klint-darwin-arm64": "*",
+    "@konvert7/klint-darwin-x64": "*",
+    "@konvert7/klint-linux-x64": "*",
+    "@konvert7/klint-win32-x64": "*"
+  },
   "devDependencies": {
     "@biomejs/biome": "2.4.7",
     "@commitlint/cli": "^20.5.3",

package/tools/prepare-native-release.ts

@@ -0,0 +1,162 @@
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { nativePackages } from "../core/native-binary";
+
+interface PackageJson {
+  name: string;
+  version: string;
+  private?: boolean;
+  optionalDependencies?: Record<string, string>;
+}
+
+interface Options {
+  version: string;
+  outDir: string;
+  requireBinaries: boolean;
+  keep: boolean;
+}
+
+const root = fileURLToPath(new URL("..", import.meta.url));
+const options = parseArgs();
+
+if (existsSync(options.outDir)) {
+  rmSync(options.outDir, { recursive: true, force: true });
+}
+mkdirSync(options.outDir, { recursive: true });
+
+try {
+  const releaseRootPackageJson = prepareRootPackageJson();
+  const nativeResults = nativePackages().map(prepareNativePackage);
+
+  validateRootPackageJson(releaseRootPackageJson);
+  for (const result of nativeResults) validateNativePackage(result.packageJson);
+
+  const missing = nativeResults
+    .filter((result) => !result.binaryCopied)
+    .map((result) => result.packageJson.name);
+
+  if (options.requireBinaries && missing.length > 0) {
+    fail(`Missing native release binaries:\n${missing.join("\n")}`);
+  }
+
+  process.stdout.write(
+    `${[
+      `native release dry-run ok (${options.version})`,
+      `output: ${options.outDir}`,
+      `native packages: ${nativeResults.length}`,
+      missing.length > 0
+        ? `missing binaries: ${missing.join(", ")}`
+        : "missing binaries: none",
+    ].join("\n")}\n`
+  );
+} finally {
+  if (!options.keep) {
+    rmSync(options.outDir, { recursive: true, force: true });
+  }
+}
+
+function prepareRootPackageJson(): PackageJson {
+  const packageJson = readPackageJson(join(root, "package.json"));
+  packageJson.version = options.version;
+  packageJson.optionalDependencies = Object.fromEntries(
+    nativePackages().map((nativePackage) => [nativePackage.packageName, options.version])
+  );
+
+  const outPath = join(options.outDir, "package.json");
+  writeJson(outPath, packageJson);
+  return packageJson;
+}
+
+function prepareNativePackage(nativePackage: ReturnType<typeof nativePackages>[number]): {
+  binaryCopied: boolean;
+  packageJson: PackageJson;
+} {
+  const packageDirName = `${nativePackage.platform}-${nativePackage.arch}`;
+  const sourceDir = join(root, "npm", "native", packageDirName);
+  const outDir = join(options.outDir, "npm", "native", packageDirName);
+  mkdirSync(outDir, { recursive: true });
+
+  const packageJson = readPackageJson(join(sourceDir, "package.json"));
+  packageJson.version = options.version;
+  packageJson.private = false;
+  writeJson(join(outDir, "package.json"), packageJson);
+
+  const sourceBinary = join(sourceDir, nativePackage.binaryPath);
+  const outBinary = join(outDir, nativePackage.binaryPath);
+  const binaryCopied = existsSync(sourceBinary);
+  if (binaryCopied) {
+    mkdirSync(dirname(outBinary), { recursive: true });
+    copyFileSync(sourceBinary, outBinary);
+  }
+
+  return { binaryCopied, packageJson };
+}
+
+function validateRootPackageJson(packageJson: PackageJson): void {
+  const optionalDependencies = packageJson.optionalDependencies ?? {};
+  for (const nativePackage of nativePackages()) {
+    if (optionalDependencies[nativePackage.packageName] !== options.version) {
+      fail(
+        `Root optional dependency ${nativePackage.packageName} is not pinned to ${options.version}`
+      );
+    }
+  }
+}
+
+function validateNativePackage(packageJson: PackageJson): void {
+  if (packageJson.version !== options.version) {
+    fail(
+      `${packageJson.name} version is ${packageJson.version}, expected ${options.version}`
+    );
+  }
+  if (packageJson.private !== false) {
+    fail(`${packageJson.name} private must be false in release prep output`);
+  }
+}
+
+function readPackageJson(path: string): PackageJson {
+  return JSON.parse(readFileSync(path, "utf-8")) as PackageJson;
+}
+
+function writeJson(path: string, value: unknown): void {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function parseArgs(): Options {
+  const args = process.argv.slice(2);
+  const version = valueAfter(args, "--version");
+  if (!version) {
+    fail(
+      "Usage: bun tools/prepare-native-release.ts --version <version> [--out <dir>] [--require-binaries] [--keep]"
+    );
+  }
+
+  return {
+    version,
+    outDir: resolve(
+      valueAfter(args, "--out") ?? mkdtempSync(join(tmpdir(), "klint-native-release-"))
+    ),
+    requireBinaries: args.includes("--require-binaries"),
+    keep: args.includes("--keep"),
+  };
+}
+
+function valueAfter(args: string[], name: string): string | undefined {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+function fail(message: string): never {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}

package/tools/semantic-release-root-npm.js

@@ -0,0 +1,52 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export async function verifyConditions(_, context) {
+  const cwd = context.cwd ?? process.cwd();
+  const packageJson = readPackageJson(cwd);
+
+  if (!packageJson.name) {
+    throw new Error("Root package.json must have a name before npm publish");
+  }
+}
+
+export async function prepare(_, context) {
+  const cwd = context.cwd ?? process.cwd();
+  const version = context.nextRelease?.version;
+
+  if (!version) {
+    throw new Error("semantic-release did not provide nextRelease.version");
+  }
+
+  const packageJson = readPackageJson(cwd);
+  packageJson.version = version;
+  writePackageJson(cwd, packageJson);
+}
+
+export async function publish(_, context) {
+  const cwd = context.cwd ?? process.cwd();
+
+  if (context.options?.dryRun) {
+    context.logger?.log("Dry run: skipping npm publish");
+    return;
+  }
+
+  const result = spawnSync("npm", ["publish", "--access", "public"], {
+    cwd,
+    encoding: "utf-8",
+    stdio: "inherit",
+  });
+
+  if ((result.status ?? -1) !== 0) {
+    throw new Error(`npm publish failed with exit code ${result.status ?? -1}`);
+  }
+}
+
+function readPackageJson(cwd) {
+  return JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"));
+}
+
+function writePackageJson(cwd, packageJson) {
+  writeFileSync(join(cwd, "package.json"), `${JSON.stringify(packageJson, null, 2)}\n`);
+}