@konvert7/klint 0.38.0 → 1.0.0

package/cli/output.ts

@@ -1,178 +0,0 @@
-import type { KlintDebugEvent, runKlint } from "../core/runner";
-import type { Violation } from "../core/types";
-
-export 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`;
-}
-
-export function writeTextOutput(
-  violations: Array<Omit<Violation, "fix">>,
-  startedAt: number
-): never {
-  const errors = violations.filter((v) => v.severity === "error");
-  const warns = violations.filter((v) => v.severity === "warn");
-
-  if (errors.length === 0 && warns.length === 0) {
-    process.stdout.write(`klint: 0 violations in ${formatDuration(startedAt)}\n`);
-    process.exit(0);
-  }
-
-  const formatBlock = (v: (typeof violations)[number]) => {
-    const prefix = v.severity === "warn" ? "⚠" : "×";
-    const header = `${v.file}:${v.line}  [${v.rule}]`;
-    const sep = "━".repeat(Math.max(0, 80 - header.length));
-    return `${header} ${sep}\n\n  ${prefix} ${v.message}\n`;
-  };
-
-  if (warns.length > 0) {
-    process.stderr.write(
-      `klint: ${warns.length} warning(s)\n\n${warns.map(formatBlock).join("\n")}`
-    );
-  }
-  if (errors.length > 0) {
-    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);
-}
-
-export interface JsonPayload {
-  violations: Array<Omit<Violation, "fix"> & { fix: unknown }>;
-  summary: {
-    errors: number;
-    warnings: number;
-  };
-}
-
-export function emptyJsonPayload(): JsonPayload {
-  return {
-    violations: [],
-    summary: { errors: 0, warnings: 0 },
-  };
-}
-
-export function toJsonPayload(violations: ReturnType<typeof runKlint>): JsonPayload {
-  const errors = violations.filter((v) => v.severity === "error");
-  return {
-    violations: violations.map((v) => ({ ...v, fix: v.fix ?? null })),
-    summary: { errors: errors.length, warnings: violations.length - errors.length },
-  };
-}
-
-export function mergeJsonOutputs(...outputs: JsonPayload[]): JsonPayload {
-  const violations = outputs
-    .flatMap((output) => output.violations)
-    .sort(
-      (a, b) =>
-        a.file.localeCompare(b.file) ||
-        a.line - b.line ||
-        a.rule.localeCompare(b.rule) ||
-        a.message.localeCompare(b.message)
-    );
-  const errors = violations.filter((violation) => violation.severity === "error").length;
-  return {
-    violations,
-    summary: {
-      errors,
-      warnings: violations.length - errors,
-    },
-  };
-}
-
-export function withAdvisories(
-  stdout: string,
-  advisories: Array<Omit<Violation, "fix">>
-): string {
-  if (advisories.length === 0) return stdout;
-  const payload = parseJsonPayload(stdout);
-  if (!isJsonPayload(payload)) return stdout;
-
-  const violations = [
-    ...payload.violations,
-    ...advisories.map((advisory) => ({ ...advisory, fix: null })),
-  ];
-  const errors = violations.filter((v) => v.severity === "error").length;
-  return JSON.stringify({
-    violations,
-    summary: { errors, warnings: violations.length - errors },
-  });
-}
-
-export function isJsonPayload(value: unknown): value is JsonPayload {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value as Partial<JsonPayload>;
-  return Array.isArray(candidate.violations) && typeof candidate.summary === "object";
-}
-
-export function toJsonCliResult(violations: ReturnType<typeof runKlint>): {
-  stdout: string;
-  status: number;
-} {
-  const payload = toJsonPayload(violations);
-  return {
-    stdout: JSON.stringify(payload),
-    status: payload.summary.errors > 0 ? 2 : 0,
-  };
-}
-
-export function writeDebugEvent(event: KlintDebugEvent): void {
-  switch (event.type) {
-    case "walk:start":
-      process.stderr.write(`[klint:debug] walk ${event.dir}\n`);
-      break;
-    case "walk:done":
-      process.stderr.write(`[klint:debug] walked ${event.dir} (${event.files} files)\n`);
-      break;
-    case "files:resolved":
-      process.stderr.write(`[klint:debug] resolved ${event.files} files\n`);
-      break;
-    case "rule:start":
-      process.stderr.write(
-        `[klint:debug] rule ${event.rule} start (${event.files} files)\n`
-      );
-      break;
-    case "rule:done":
-      process.stderr.write(
-        `[klint:debug] rule ${event.rule} done (${event.violations} violations)\n`
-      );
-      break;
-    case "arch:start":
-      process.stderr.write(`[klint:debug] arch start (${event.files} files)\n`);
-      break;
-    case "arch:done":
-      process.stderr.write(`[klint:debug] arch done (${event.violations} violations)\n`);
-      break;
-  }
-}
-
-export function parseJsonPayload(value: string): unknown {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return undefined;
-  }
-}
-
-export function jsonPayloadEquals(a: unknown, b: unknown): boolean {
-  return JSON.stringify(canonicalJson(a)) === JSON.stringify(canonicalJson(b));
-}
-
-function canonicalJson(value: unknown): unknown {
-  if (Array.isArray(value)) {
-    return value
-      .map(canonicalJson)
-      .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
-  }
-  if (!value || typeof value !== "object") return value;
-  return Object.fromEntries(
-    Object.entries(value)
-      .sort(([left], [right]) => left.localeCompare(right))
-      .map(([key, entry]) => [key, canonicalJson(entry)])
-  );
-}

package/cli/paths.ts

@@ -1,20 +0,0 @@
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-
-export const PACKAGE_ROOT = resolve(import.meta.dir, "..");
-
-export const SHIPPED_SKILL_PATH = resolve(
-  PACKAGE_ROOT,
-  "skill",
-  "klint-rules",
-  "SKILL.md"
-);
-
-export function installedVersion(): string {
-  try {
-    const manifest = readFileSync(resolve(PACKAGE_ROOT, "package.json"), "utf-8");
-    return (JSON.parse(manifest) as { version?: string }).version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}

package/cli/rust-config.ts

@@ -1,145 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { resolveNativePackageBinary } from "../core/native-binary";
-import type { RuleConfigValue } from "../core/types";
-import { BUILT_IN_PLUGINS } from "../plugins/index";
-import { PACKAGE_ROOT } from "./paths";
-
-const RUST_SUPPORTED_RULES = new Set([
-  "no-async-predicate",
-  "no-consecutive-array-push",
-  "no-nested-template-literals",
-  "no-string-match",
-  "no-sync-in-async",
-  "no-unguarded-json-parse",
-  "sonar/no-single-char-class",
-  "sonar/prefer-at",
-  "sonar/prefer-nullish-coalescing-assign",
-  "sonar/prefer-string-replaceall",
-  "sonar/prefer-string-raw",
-  "sonar/prefer-string-raw-regexp",
-]);
-
-export function splitRulesForAuto(rules: Record<string, RuleConfigValue>): {
-  rustRules: Record<string, RuleConfigValue>;
-  tsRules: Record<string, RuleConfigValue>;
-} {
-  const rustRules: Record<string, RuleConfigValue> = {};
-  const tsRules: Record<string, RuleConfigValue> = {};
-
-  for (const [name, value] of Object.entries(rules)) {
-    if (RUST_SUPPORTED_RULES.has(name)) rustRules[name] = value;
-    else tsRules[name] = value;
-  }
-
-  return { rustRules, tsRules };
-}
-
-export interface RustEngineCommand {
-  bin: string;
-  args: string[];
-}
-
-export function resolveRustEngineCommand(configDir: string): RustEngineCommand {
-  const args = ["--config", configDir, "--json"];
-  const explicitBin = process.env.KLINT_RUST_BIN;
-  if (explicitBin) {
-    return { bin: explicitBin, args };
-  }
-
-  const localBin = join(
-    PACKAGE_ROOT,
-    "target",
-    "debug",
-    process.platform === "win32" ? "klint-rs.exe" : "klint-rs"
-  );
-  if (isSourceCheckout() && existsSync(localBin)) {
-    return { bin: localBin, args };
-  }
-
-  const nativePackageBin = resolveNativePackageBinary({ packageRoot: PACKAGE_ROOT });
-  if (nativePackageBin) {
-    return { bin: nativePackageBin, args };
-  }
-
-  if (!isSourceCheckout()) {
-    process.stderr.write(
-      "klint: native Rust engine binary is unavailable for this package version\n"
-    );
-    process.exit(1);
-  }
-
-  return {
-    bin: "cargo",
-    args: ["run", "--quiet", "-p", "klint-rs", "--", ...args],
-  };
-}
-
-function isSourceCheckout(): boolean {
-  return existsSync(join(PACKAGE_ROOT, "crates", "klint-rs", "Cargo.toml"));
-}
-
-export function rustEngineUnsupportedReason({
-  fix,
-  raw,
-  rulesFile,
-}: {
-  fix: boolean;
-  raw: {
-    plugins?: string[];
-    rules?: Record<string, RuleConfigValue>;
-    arch?: unknown;
-  };
-  rulesFile?: string;
-}): string | undefined {
-  if (fix) return "KLINT_ENGINE=rust does not support --fix";
-  if (rulesFile) return "KLINT_ENGINE=rust does not support --rules";
-  let effectiveRules: Record<string, RuleConfigValue>;
-  try {
-    effectiveRules = resolveEffectiveRules(raw.plugins, raw.rules ?? {});
-  } catch (error) {
-    return error instanceof Error
-      ? error.message
-      : "KLINT_ENGINE=rust failed to load plugins";
-  }
-  const activeSupportedRules = Object.entries(effectiveRules).filter(
-    ([name, value]) =>
-      ruleConfigSeverity(value) !== "off" && RUST_SUPPORTED_RULES.has(name)
-  );
-  const unsupportedRules = Object.entries(effectiveRules)
-    .filter(
-      ([name, value]) =>
-        ruleConfigSeverity(value) !== "off" && !RUST_SUPPORTED_RULES.has(name)
-    )
-    .map(([name]) => name);
-  if (!raw.arch && activeSupportedRules.length === 0 && unsupportedRules.length === 0) {
-    return "KLINT_ENGINE=rust requires an arch config or supported rule";
-  }
-  if (unsupportedRules.length > 0) {
-    return [
-      "Rust engine currently supports arch rules and selected rules only",
-      "",
-      "Unsupported rules:",
-      ...unsupportedRules.map((rule) => `- ${rule}`),
-    ].join("\n");
-  }
-  return undefined;
-}
-
-export function resolveEffectiveRules(
-  plugins: string[] | undefined,
-  rules: Record<string, RuleConfigValue>
-): Record<string, RuleConfigValue> {
-  const pluginDefaults: Record<string, RuleConfigValue> = {};
-  for (const pluginName of plugins ?? []) {
-    const plugin = BUILT_IN_PLUGINS[pluginName];
-    if (!plugin) throw new Error(`Unknown klint plugin: "${pluginName}"`);
-    Object.assign(pluginDefaults, plugin.rules);
-  }
-  return { ...pluginDefaults, ...rules };
-}
-
-export function ruleConfigSeverity(value: RuleConfigValue): string | undefined {
-  if (typeof value === "string") return value;
-  return value.severity;
-}

package/cli/rust-engine.ts

@@ -1,323 +0,0 @@
-import { type SpawnSyncReturns, spawnSync } from "node:child_process";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { runKlint } from "../core/runner";
-import type { RunRecorder } from "../core/stats";
-import type { KlintRule, RuleConfigValue, Violation } from "../core/types";
-import {
-  emptyJsonPayload,
-  isJsonPayload,
-  type JsonPayload,
-  jsonPayloadEquals,
-  mergeJsonOutputs,
-  parseJsonPayload,
-  toJsonCliResult,
-  toJsonPayload,
-  withAdvisories,
-  writeTextOutput,
-} from "./output";
-import { PACKAGE_ROOT } from "./paths";
-import {
-  resolveEffectiveRules,
-  resolveRustEngineCommand,
-  ruleConfigSeverity,
-  rustEngineUnsupportedReason,
-  splitRulesForAuto,
-} from "./rust-config";
-
-const RUST_CHILD_ENV = { ...process.env, KLINT_NO_STATS: "1" };
-
-export function runRustEngine({
-  advisories,
-  fix,
-  json,
-  raw,
-  record,
-  root,
-  rulesFile,
-  startedAt,
-}: {
-  advisories: Array<Omit<Violation, "fix">>;
-  fix: boolean;
-  json: boolean;
-  raw: {
-    plugins?: string[];
-    rules?: Record<string, RuleConfigValue>;
-    arch?: unknown;
-  };
-  record: RunRecorder;
-  root: string;
-  rulesFile?: string;
-  startedAt: number;
-}): void {
-  const unsupportedReason = rustEngineUnsupportedReason({
-    fix,
-    raw,
-    rulesFile,
-  });
-
-  if (unsupportedReason) {
-    process.stderr.write(`klint: ${unsupportedReason}\n`);
-    process.exit(1);
-  }
-
-  const { configDir: rustConfigDir, cleanup } = writeRustEngineConfig({ raw, root });
-  const command = resolveRustEngineCommand(rustConfigDir);
-  let result: SpawnSyncReturns<string>;
-  try {
-    if (process.argv.includes("--debug") || process.argv.includes("-debug")) {
-      process.stderr.write(
-        `[klint:debug] rust engine: ${command.bin} ${command.args.join(" ")}\n`
-      );
-    }
-    result = spawnSync(command.bin, command.args, {
-      cwd: PACKAGE_ROOT,
-      encoding: "utf-8",
-      env: RUST_CHILD_ENV,
-    });
-  } finally {
-    cleanup();
-  }
-
-  if (result.stderr) process.stderr.write(result.stderr);
-  const payload = parseJsonPayload(result.stdout);
-  if (isJsonPayload(payload)) record(payload.violations);
-  if (json) {
-    if (result.stdout) process.stdout.write(withAdvisories(result.stdout, advisories));
-    process.exit(result.status ?? 1);
-  }
-
-  if (!isJsonPayload(payload)) {
-    process.stderr.write("klint: --engine rust failed to parse Rust JSON output\n");
-    process.exit(1);
-  }
-  writeTextOutput([...payload.violations, ...advisories], startedAt);
-}
-
-export function runCompareEngine({
-  advisories,
-  fix,
-  json,
-  raw,
-  record,
-  root,
-  rulesFile,
-  tsViolations,
-}: {
-  advisories: Array<Omit<Violation, "fix">>;
-  fix: boolean;
-  json: boolean;
-  raw: {
-    plugins?: string[];
-    rules?: Record<string, RuleConfigValue>;
-    arch?: unknown;
-  };
-  record: RunRecorder;
-  root: string;
-  rulesFile?: string;
-  tsViolations: ReturnType<typeof runKlint>;
-}): void {
-  if (!json) {
-    process.stderr.write("klint: --engine compare currently requires --json\n");
-    process.exit(1);
-  }
-
-  const unsupportedReason = rustEngineUnsupportedReason({
-    fix,
-    raw,
-    rulesFile,
-  });
-
-  if (unsupportedReason) {
-    process.stderr.write(`klint: ${unsupportedReason}\n`);
-    process.exit(1);
-  }
-
-  const tsResult = toJsonCliResult(tsViolations);
-  const { configDir: rustConfigDir, cleanup } = writeRustEngineConfig({ raw, root });
-  const rustCommand = resolveRustEngineCommand(rustConfigDir);
-  let rustResult: SpawnSyncReturns<string>;
-  try {
-    rustResult = spawnSync(rustCommand.bin, rustCommand.args, {
-      cwd: PACKAGE_ROOT,
-      encoding: "utf-8",
-      env: RUST_CHILD_ENV,
-    });
-  } finally {
-    cleanup();
-  }
-
-  const rustStatus = rustResult.status ?? 1;
-  if (rustResult.stderr) process.stderr.write(rustResult.stderr);
-
-  const tsPayload = parseJsonPayload(tsResult.stdout);
-  const rustPayload = parseJsonPayload(rustResult.stdout);
-
-  if (
-    rustStatus !== tsResult.status ||
-    tsPayload === undefined ||
-    rustPayload === undefined ||
-    !jsonPayloadEquals(tsPayload, rustPayload)
-  ) {
-    const mismatchLines = [
-      "klint: compare engine mismatch",
-      `TypeScript exit: ${tsResult.status}`,
-      `Rust exit: ${rustStatus}`,
-    ];
-    process.stderr.write(`${mismatchLines.join("\n")}\n`);
-    process.exit(1);
-  }
-
-  record(tsViolations);
-  process.stdout.write(withAdvisories(tsResult.stdout, advisories));
-  process.exit(tsResult.status);
-}
-
-function writeRustEngineConfig({
-  raw,
-  root,
-}: {
-  raw: {
-    include?: string[];
-    plugins?: string[];
-    rules?: Record<string, RuleConfigValue>;
-    arch?: unknown;
-  };
-  root: string;
-}): { configDir: string; cleanup: () => void } {
-  const tempDir = mkdtempSync(join(tmpdir(), "klint-rust-engine-"));
-  writeFileSync(
-    join(tempDir, "klint.config.json"),
-    JSON.stringify({
-      root,
-      include: raw.include ?? ["."],
-      plugins: [],
-      rules: resolveEffectiveRules(raw.plugins, raw.rules ?? {}),
-      arch: raw.arch,
-    })
-  );
-  return {
-    configDir: tempDir,
-    cleanup: () => rmSync(tempDir, { recursive: true, force: true }),
-  };
-}
-
-export function runAutoEngine({
-  advisories,
-  fix,
-  json,
-  raw,
-  record,
-  root,
-  rulesFile,
-  startedAt,
-  customRules,
-  customRulesMap,
-}: {
-  advisories: Array<Omit<Violation, "fix">>;
-  fix: boolean;
-  json: boolean;
-  raw: {
-    root?: string;
-    include?: string[];
-    plugins?: string[];
-    rules?: Record<string, RuleConfigValue>;
-    arch?: unknown;
-  };
-  record: RunRecorder;
-  root: string;
-  rulesFile?: string;
-  startedAt: number;
-  customRules: Record<string, KlintRule>;
-  customRulesMap: Record<string, RuleConfigValue>;
-}): void {
-  if (fix) {
-    process.stderr.write("klint: --engine auto does not support --fix\n");
-    process.exit(1);
-  }
-  if (rulesFile) {
-    process.stderr.write("klint: --engine auto does not support --rules\n");
-    process.exit(1);
-  }
-
-  const effectiveRules = resolveEffectiveRules(raw.plugins, raw.rules ?? {});
-  const { rustRules, tsRules } = splitRulesForAuto(effectiveRules);
-  const tsViolations = runKlint(
-    {
-      root,
-      include: raw.include ?? ["."],
-      plugins: [],
-      rules: { ...customRulesMap, ...tsRules },
-    },
-    customRules
-  );
-
-  const rustOutput = runAutoRustSubset({
-    raw,
-    root,
-    rustRules,
-  });
-  const tsOutput = toJsonPayload(tsViolations);
-  const merged = mergeJsonOutputs(rustOutput, tsOutput);
-  record(merged.violations);
-  if (json) {
-    process.stdout.write(withAdvisories(JSON.stringify(merged), advisories));
-    process.exit(merged.summary.errors > 0 ? 2 : 0);
-  }
-  writeTextOutput([...merged.violations, ...advisories], startedAt);
-}
-
-function runAutoRustSubset({
-  raw,
-  root,
-  rustRules,
-}: {
-  raw: {
-    include?: string[];
-    arch?: unknown;
-  };
-  root: string;
-  rustRules: Record<string, RuleConfigValue>;
-}): JsonPayload {
-  const hasRustRules = Object.values(rustRules).some(
-    (value) => ruleConfigSeverity(value) !== "off"
-  );
-  if (!raw.arch && !hasRustRules) {
-    return emptyJsonPayload();
-  }
-
-  const tempDir = mkdtempSync(join(tmpdir(), "klint-auto-rust-"));
-  try {
-    writeFileSync(
-      join(tempDir, "klint.config.json"),
-      JSON.stringify({
-        root,
-        include: raw.include ?? ["."],
-        rules: rustRules,
-        arch: raw.arch,
-      })
-    );
-
-    const command = resolveRustEngineCommand(tempDir);
-    const result = spawnSync(command.bin, command.args, {
-      cwd: PACKAGE_ROOT,
-      encoding: "utf-8",
-      env: RUST_CHILD_ENV,
-    });
-    if (result.stderr) process.stderr.write(result.stderr);
-    if ((result.status ?? 1) !== 0 && (result.status ?? 1) !== 2) {
-      process.stderr.write(result.stdout);
-      process.exit(result.status ?? 1);
-    }
-
-    const payload = parseJsonPayload(result.stdout);
-    if (!isJsonPayload(payload)) {
-      process.stderr.write("klint: --engine auto failed to parse Rust JSON output\n");
-      process.exit(1);
-    }
-    return payload;
-  } finally {
-    rmSync(tempDir, { recursive: true, force: true });
-  }
-}