@konvert7/klint 0.9.0 → 0.10.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.10.0",
   "description": "Architecture-as-Code linter for TypeScript. Enforce layer boundaries, import rules, and singleton patterns in YAML.",
   "type": "module",
   "bin": {
@@ -35,6 +35,10 @@
   "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",
     "check": "biome check",
     "check-write": "biome check --write",
     "knip": "knip-bun",