@konvert7/klint 0.12.1 → 0.15.0

package/cli.ts

@@ -24,6 +24,7 @@ interface CliOptions {
 }
 
 export async function main(opts: CliOptions = {}): Promise<void> {
+  const startedAt = performance.now();
   const args = process.argv.slice(2);
 
   if (args[0] === "help" || args[0] === "h") {
@@ -153,7 +154,7 @@ export async function main(opts: CliOptions = {}): Promise<void> {
       unfixed > 0
         ? `klint: applied ${totalApplied} fix(es). ${unfixed} violation(s) require manual attention.`
         : `klint: applied ${totalApplied} fix(es). No remaining violations.`;
-    process.stdout.write(JSON.stringify({ output: msg }));
+    process.stdout.write(`${msg} Finished in ${formatDuration(startedAt)}.\n`);
     process.exit(0);
   }
 
@@ -161,7 +162,7 @@ export async function main(opts: CliOptions = {}): Promise<void> {
   const warns = violations.filter((v) => v.severity === "warn");
 
   if (errors.length === 0 && warns.length === 0) {
-    process.stdout.write(JSON.stringify({ output: "klint: 0 violations" }));
+    process.stdout.write(`klint: 0 violations in ${formatDuration(startedAt)}\n`);
     process.exit(0);
   }
 
@@ -181,11 +182,19 @@ export async function main(opts: CliOptions = {}): Promise<void> {
     process.stderr.write(
       `klint: ${errors.length} error(s)\n\n${errors.map(formatBlock).join("\n")}`
     );
+    process.stderr.write(`\nklint: finished in ${formatDuration(startedAt)}\n`);
     process.exit(2);
   }
+  process.stderr.write(`\nklint: finished in ${formatDuration(startedAt)}\n`);
   process.exit(0);
 }
 
+function formatDuration(startedAt: number): string {
+  const elapsedMs = performance.now() - startedAt;
+  if (elapsedMs < 1000) return `${Math.round(elapsedMs)}ms`;
+  return `${(elapsedMs / 1000).toFixed(elapsedMs < 10_000 ? 2 : 1)}s`;
+}
+
 function runRustEngine({
   configDir,
   fix,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konvert7/klint",
-  "version": "0.12.1",
+  "version": "0.15.0",
   "description": "Architecture-as-Code linter for TypeScript. Enforce layer boundaries, import rules, and singleton patterns in YAML.",
   "type": "module",
   "bin": {
@@ -60,12 +60,6 @@
     "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

@@ -69,9 +69,7 @@ try {
 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])
-  );
+  delete packageJson.optionalDependencies;
 
   const outPath = join(options.outDir, "package.json");
   writeJson(outPath, packageJson);
@@ -106,9 +104,9 @@ function prepareNativePackage(nativePackage: ReturnType<typeof nativePackages>[n
 function validateRootPackageJson(packageJson: PackageJson): void {
   const optionalDependencies = packageJson.optionalDependencies ?? {};
   for (const nativePackage of nativePackages()) {
-    if (optionalDependencies[nativePackage.packageName] !== options.version) {
+    if (nativePackage.packageName in optionalDependencies) {
       fail(
-        `Root optional dependency ${nativePackage.packageName} is not pinned to ${options.version}`
+        `Root package must not consume dark native package ${nativePackage.packageName}`
       );
     }
   }

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

@@ -0,0 +1,117 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+
+const NATIVE_PACKAGES = [
+  {
+    dir: "darwin-arm64",
+    name: "@konvert7/klint-darwin-arm64",
+    binaryPath: "bin/klint-rs",
+  },
+  {
+    dir: "darwin-x64",
+    name: "@konvert7/klint-darwin-x64",
+    binaryPath: "bin/klint-rs",
+  },
+  {
+    dir: "linux-x64",
+    name: "@konvert7/klint-linux-x64",
+    binaryPath: "bin/klint-rs",
+  },
+  {
+    dir: "win32-x64",
+    name: "@konvert7/klint-win32-x64",
+    binaryPath: "bin/klint-rs.exe",
+  },
+];
+
+export async function verifyConditions(_, context) {
+  const cwd = context.cwd ?? process.cwd();
+
+  for (const nativePackage of NATIVE_PACKAGES) {
+    const packageJson = readPackageJson(packageDir(cwd, nativePackage));
+    if (packageJson.name !== nativePackage.name) {
+      throw new Error(
+        `${nativePackage.dir} package name is ${packageJson.name}, expected ${nativePackage.name}`
+      );
+    }
+  }
+}
+
+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");
+  }
+
+  for (const nativePackage of NATIVE_PACKAGES) {
+    const dir = packageDir(cwd, nativePackage);
+    const packageJson = readPackageJson(dir);
+    packageJson.version = version;
+    packageJson.private = false;
+    writePackageJson(dir, packageJson);
+
+    const binary = join(dir, nativePackage.binaryPath);
+    if (!existsSync(binary)) {
+      throw new Error(`Missing native binary for ${nativePackage.name}: ${binary}`);
+    }
+  }
+}
+
+export async function publish(pluginConfig = {}, context) {
+  const cwd = context.cwd ?? process.cwd();
+  const spawn = pluginConfig.spawnSync ?? spawnSync;
+
+  if (context.options?.dryRun) {
+    context.logger?.log("Dry run: skipping native npm publishes");
+    return;
+  }
+
+  for (const nativePackage of NATIVE_PACKAGES) {
+    const result = spawn("npm", ["publish", "--access", "public"], {
+      cwd: packageDir(cwd, nativePackage),
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    if (result.stdout) process.stdout.write(result.stdout);
+    if (result.stderr) process.stderr.write(result.stderr);
+
+    if ((result.status ?? -1) !== 0) {
+      if (isMissingPackagePublishFailure(result)) {
+        context.logger?.log(
+          `Skipping ${nativePackage.name}: npm package is not available to this trusted publisher yet`
+        );
+        continue;
+      }
+
+      throw new Error(
+        `${nativePackage.name} npm publish failed with exit code ${result.status ?? -1}`
+      );
+    }
+  }
+}
+
+function packageDir(cwd, nativePackage) {
+  return join(cwd, "npm", "native", nativePackage.dir);
+}
+
+function readPackageJson(dir) {
+  return JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+}
+
+function writePackageJson(dir, packageJson) {
+  writeFileSync(join(dir, "package.json"), `${JSON.stringify(packageJson, null, 2)}\n`);
+}
+
+function isMissingPackagePublishFailure(result) {
+  const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+  return (
+    output.includes("npm error code E404") ||
+    output.includes("404 Not Found") ||
+    output.includes("package not found") ||
+    output.includes("could not be found or you do not have permission")
+  );
+}