@konvert7/klint 0.9.0 → 0.11.0

package/cli.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+import { spawnSync } from "node:child_process";
 import {
   cpSync,
   existsSync,
@@ -11,6 +12,7 @@ import { dirname, join, relative, resolve } from "node:path";
 import * as clack from "@clack/prompts";
 import { parse as parseYaml } from "yaml";
 import { applyFixes } from "./core/fixer";
+import { resolveNativePackageBinary } from "./core/native-binary";
 import { runKlint } from "./core/runner";
 import type { ArchConfig, KlintConfig, KlintRule, RuleConfigValue } from "./core/types";
 import { BUILT_IN_PLUGINS } from "./plugins/index";
@@ -80,6 +82,12 @@ export async function main(opts: CliOptions = {}): Promise<void> {
     process.exit(1);
   }
   const root = resolve(configDir, raw.root ?? ".");
+  const engine = process.env.KLINT_ENGINE;
+
+  if (engine === "rust") {
+    runRustEngine({ configDir, fix, json, raw, rulesFile });
+    return;
+  }
 
   let customRules: Record<string, KlintRule> = {};
   const defaultRulesPath = resolve(configDir, "klint.rules.ts");
@@ -174,6 +182,105 @@ export async function main(opts: CliOptions = {}): Promise<void> {
   process.exit(0);
 }
 
+function runRustEngine({
+  configDir,
+  fix,
+  json,
+  raw,
+  rulesFile,
+}: {
+  configDir: string;
+  fix: boolean;
+  json: boolean;
+  raw: {
+    plugins?: string[];
+    rules?: Record<string, RuleConfigValue>;
+    arch?: unknown;
+  };
+  rulesFile?: string;
+}): void {
+  const unsupportedReason = rustEngineUnsupportedReason({
+    fix,
+    json,
+    raw,
+    rulesFile,
+  });
+
+  if (unsupportedReason) {
+    process.stderr.write(`klint: ${unsupportedReason}\n`);
+    process.exit(1);
+  }
+
+  const command = resolveRustEngineCommand(configDir);
+  const result = spawnSync(command.bin, command.args, {
+    cwd: import.meta.dir,
+    encoding: "utf-8",
+  });
+
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  process.exit(result.status ?? 1);
+}
+
+interface RustEngineCommand {
+  bin: string;
+  args: string[];
+}
+
+function resolveRustEngineCommand(configDir: string): RustEngineCommand {
+  const args = ["--config", configDir, "--json"];
+  const explicitBin = process.env.KLINT_RUST_BIN;
+  if (explicitBin) {
+    return { bin: explicitBin, args };
+  }
+
+  const nativePackageBin = resolveNativePackageBinary({ packageRoot: import.meta.dir });
+  if (nativePackageBin) {
+    return { bin: nativePackageBin, args };
+  }
+
+  const localBin = join(
+    import.meta.dir,
+    "target",
+    "debug",
+    process.platform === "win32" ? "klint-rs.exe" : "klint-rs"
+  );
+  if (existsSync(localBin)) {
+    return { bin: localBin, args };
+  }
+
+  return {
+    bin: "cargo",
+    args: ["run", "--quiet", "-p", "klint-rs", "--", ...args],
+  };
+}
+
+function rustEngineUnsupportedReason({
+  fix,
+  json,
+  raw,
+  rulesFile,
+}: {
+  fix: boolean;
+  json: boolean;
+  raw: {
+    plugins?: string[];
+    rules?: Record<string, RuleConfigValue>;
+    arch?: unknown;
+  };
+  rulesFile?: string;
+}): string | undefined {
+  if (!json) return "KLINT_ENGINE=rust currently requires --json";
+  if (fix) return "KLINT_ENGINE=rust does not support --fix";
+  if (rulesFile) return "KLINT_ENGINE=rust does not support --rules";
+  if (!raw.arch) return "KLINT_ENGINE=rust requires an arch config";
+  if ((raw.plugins?.length ?? 0) > 0) return "KLINT_ENGINE=rust does not support plugins";
+  if (Object.values(raw.rules ?? {}).some((value) => value !== "off")) {
+    return "KLINT_ENGINE=rust does not support TypeScript rules";
+  }
+  return undefined;
+}
+
 const AGENT_TARGETS = [
   { value: "claude", label: "Claude Code" },
   { value: "opencode", label: "opencode" },

package/core/native-binary.ts

@@ -0,0 +1,95 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+type NativePlatform = "darwin" | "linux" | "win32";
+type NativeArch = "arm64" | "x64";
+
+export interface NativePackage {
+  platform: NativePlatform;
+  arch: NativeArch;
+  packageName: string;
+  binaryPath: string;
+}
+
+const NATIVE_PACKAGES: Record<string, NativePackage> = {
+  "darwin-arm64": {
+    platform: "darwin",
+    arch: "arm64",
+    packageName: "@konvert7/klint-darwin-arm64",
+    binaryPath: "bin/klint-rs",
+  },
+  "darwin-x64": {
+    platform: "darwin",
+    arch: "x64",
+    packageName: "@konvert7/klint-darwin-x64",
+    binaryPath: "bin/klint-rs",
+  },
+  "linux-x64": {
+    platform: "linux",
+    arch: "x64",
+    packageName: "@konvert7/klint-linux-x64",
+    binaryPath: "bin/klint-rs",
+  },
+  "win32-x64": {
+    platform: "win32",
+    arch: "x64",
+    packageName: "@konvert7/klint-win32-x64",
+    binaryPath: "bin/klint-rs.exe",
+  },
+};
+
+interface NativeBinaryOptions {
+  packageRoot: string;
+  platform?: string;
+  arch?: string;
+  exists?: (path: string) => boolean;
+  resolvePackageJson?: (packageName: string) => string;
+}
+
+export function nativePackageForPlatform(
+  platform: string = process.platform,
+  arch: string = process.arch
+): NativePackage | undefined {
+  return NATIVE_PACKAGES[`${platform}-${arch}`];
+}
+
+export function nativePackages(): NativePackage[] {
+  return Object.values(NATIVE_PACKAGES);
+}
+
+export function resolveNativePackageBinary({
+  packageRoot,
+  platform = process.platform,
+  arch = process.arch,
+  exists = existsSync,
+  resolvePackageJson,
+}: NativeBinaryOptions): string | undefined {
+  const nativePackage = nativePackageForPlatform(platform, arch);
+  if (!nativePackage) return undefined;
+
+  const packageJsonPath = resolveOptionalPackageJson(
+    packageRoot,
+    nativePackage.packageName,
+    resolvePackageJson
+  );
+  if (!packageJsonPath) return undefined;
+
+  const binaryPath = join(dirname(packageJsonPath), nativePackage.binaryPath);
+  return exists(binaryPath) ? binaryPath : undefined;
+}
+
+function resolveOptionalPackageJson(
+  packageRoot: string,
+  packageName: string,
+  resolvePackageJson?: (packageName: string) => string
+): string | undefined {
+  try {
+    if (resolvePackageJson) return resolvePackageJson(packageName);
+    return createRequire(join(packageRoot, "package.json")).resolve(
+      `${packageName}/package.json`
+    );
+  } catch {
+    return undefined;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konvert7/klint",
-  "version": "0.9.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": {
@@ -35,6 +35,11 @@
   "scripts": {
     "type-check": "tsc --noEmit",
     "test": "bun test",
+    "test:rust-engine": "bun test tests/rust-engine-cli.test.ts",
+    "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",
@@ -55,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`);
+}