@konvert7/klint 0.24.1 → 0.25.0

package/cli.ts

@@ -1,45 +1,20 @@
 #!/usr/bin/env bun
-import { type SpawnSyncReturns, spawnSync } from "node:child_process";
-import {
-  cpSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  symlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, relative, resolve } from "node:path";
-import * as clack from "@clack/prompts";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
 import { parse as parseYaml } from "yaml";
+import { printHelp } from "./cli/help";
+import { installSkill } from "./cli/install-skill";
+import {
+  formatDuration,
+  toJsonCliResult,
+  writeDebugEvent,
+  writeTextOutput,
+} from "./cli/output";
+import { runAutoEngine, runCompareEngine, runRustEngine } from "./cli/rust-engine";
 import { applyFixes } from "./core/fixer";
-import { resolveNativePackageBinary } from "./core/native-binary";
-import { type KlintDebugEvent, runKlint } from "./core/runner";
-import type {
-  ArchConfig,
-  KlintConfig,
-  KlintRule,
-  RuleConfigValue,
-  Violation,
-} from "./core/types";
-import { BUILT_IN_PLUGINS } from "./plugins/index";
-import { BUILT_IN_RULES } from "./rules/index";
-
-const RUST_SUPPORTED_RULES = new Set([
-  "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",
-]);
+import { runKlint } from "./core/runner";
+import type { ArchConfig, KlintConfig, KlintRule, RuleConfigValue } from "./core/types";
 
 interface CliOptions {
   configDir?: string;
@@ -103,7 +78,7 @@ export async function main(opts: CliOptions = {}): Promise<void> {
   }
   let raw: RawConfig;
   try {
-    const text = readFileSync(configPath, "utf-8");
+    const text = await readFile(configPath, "utf-8");
     raw = (usingYaml ? parseYaml(text) : JSON.parse(text)) as RawConfig;
   } catch {
     process.stderr.write(`klint: failed to parse ${configPath}\n`);
@@ -217,697 +192,4 @@ export async function main(opts: CliOptions = {}): Promise<void> {
   writeTextOutput(violations, startedAt);
 }
 
-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 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);
-}
-
-function runRustEngine({
-  fix,
-  json,
-  raw,
-  root,
-  rulesFile,
-  startedAt,
-}: {
-  fix: boolean;
-  json: boolean;
-  raw: {
-    plugins?: string[];
-    rules?: Record<string, RuleConfigValue>;
-    arch?: unknown;
-  };
-  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: import.meta.dir,
-      encoding: "utf-8",
-    });
-  } finally {
-    cleanup();
-  }
-
-  if (result.stderr) process.stderr.write(result.stderr);
-  if (json) {
-    if (result.stdout) process.stdout.write(result.stdout);
-    process.exit(result.status ?? 1);
-  }
-
-  const payload = parseJsonPayload(result.stdout);
-  if (!isJsonPayload(payload)) {
-    process.stderr.write("klint: --engine rust failed to parse Rust JSON output\n");
-    process.exit(1);
-  }
-  writeTextOutput(payload.violations, startedAt);
-}
-
-function runCompareEngine({
-  fix,
-  json,
-  raw,
-  root,
-  rulesFile,
-  tsViolations,
-}: {
-  fix: boolean;
-  json: boolean;
-  raw: {
-    plugins?: string[];
-    rules?: Record<string, RuleConfigValue>;
-    arch?: unknown;
-  };
-  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: import.meta.dir,
-      encoding: "utf-8",
-    });
-  } 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);
-  }
-
-  process.stdout.write(tsResult.stdout);
-  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 }),
-  };
-}
-
-function runAutoEngine({
-  fix,
-  json,
-  raw,
-  root,
-  rulesFile,
-  startedAt,
-  customRules,
-  customRulesMap,
-}: {
-  fix: boolean;
-  json: boolean;
-  raw: {
-    root?: string;
-    include?: string[];
-    plugins?: string[];
-    rules?: Record<string, RuleConfigValue>;
-    arch?: unknown;
-  };
-  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);
-  if (json) {
-    process.stdout.write(JSON.stringify(merged));
-    process.exit(merged.summary.errors > 0 ? 2 : 0);
-  }
-  writeTextOutput(merged.violations, startedAt);
-}
-
-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 };
-}
-
-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: import.meta.dir,
-      encoding: "utf-8",
-    });
-    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 });
-  }
-}
-
-interface JsonPayload {
-  violations: Array<Omit<Violation, "fix"> & { fix: unknown }>;
-  summary: {
-    errors: number;
-    warnings: number;
-  };
-}
-
-function emptyJsonPayload(): JsonPayload {
-  return {
-    violations: [],
-    summary: { errors: 0, warnings: 0 },
-  };
-}
-
-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 },
-  };
-}
-
-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,
-    },
-  };
-}
-
-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";
-}
-
-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,
-  };
-}
-
-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;
-  }
-}
-
-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 localBin = join(
-    import.meta.dir,
-    "target",
-    "debug",
-    process.platform === "win32" ? "klint-rs.exe" : "klint-rs"
-  );
-  if (isSourceCheckout() && existsSync(localBin)) {
-    return { bin: localBin, args };
-  }
-
-  const nativePackageBin = resolveNativePackageBinary({ packageRoot: import.meta.dir });
-  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(import.meta.dir, "crates", "klint-rs", "Cargo.toml"));
-}
-
-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;
-}
-
-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 };
-}
-
-function ruleConfigSeverity(value: RuleConfigValue): string | undefined {
-  if (typeof value === "string") return value;
-  return value.severity;
-}
-
-function parseJsonPayload(value: string): unknown {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return undefined;
-  }
-}
-
-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)])
-  );
-}
-
-const AGENT_TARGETS = [
-  { value: "claude", label: "Claude Code" },
-  { value: "opencode", label: "opencode" },
-  { value: "cursor", label: "Cursor" },
-  { value: "codex", label: "Codex" },
-] as const;
-
-type AgentKey = (typeof AGENT_TARGETS)[number]["value"];
-
-const AGENT_DIRS: Record<AgentKey, string> = {
-  claude: ".claude/skills",
-  opencode: ".agents/skills",
-  cursor: ".cursor/skills",
-  codex: ".agents/skills",
-};
-
-async function installSkill(args: string[]): Promise<void> {
-  const skillSrc = join(import.meta.dir, "skill", "klint-rules");
-  if (!existsSync(skillSrc)) {
-    process.stderr.write(`klint: skill source not found at ${skillSrc}\n`);
-    process.exit(1);
-  }
-
-  // Parse non-interactive flags
-  let flagAgents: AgentKey[] | undefined;
-  let flagSymlink: boolean | undefined;
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--agents" && args[i + 1])
-      flagAgents = args[++i].split(",") as AgentKey[];
-    else if (args[i] === "--symlink") flagSymlink = true;
-    else if (args[i] === "--copy") flagSymlink = false;
-  }
-
-  let selectedAgents: AgentKey[];
-  let useSymlink: boolean;
-
-  if (!process.stdin.isTTY || flagAgents !== undefined || flagSymlink !== undefined) {
-    selectedAgents = flagAgents ?? (AGENT_TARGETS.map((a) => a.value) as AgentKey[]);
-    useSymlink = flagSymlink ?? false;
-  } else {
-    clack.intro("klint install-skill");
-
-    const agents = await clack.multiselect<AgentKey>({
-      message: "Which agents should the skill be installed for?",
-      options: AGENT_TARGETS.map((a) => ({ value: a.value, label: a.label })),
-      initialValues: AGENT_TARGETS.map((a) => a.value) as AgentKey[],
-    });
-    if (clack.isCancel(agents)) {
-      clack.cancel("Cancelled.");
-      process.exit(0);
-    }
-    selectedAgents = agents as AgentKey[];
-
-    const mode = await clack.select<"symlink" | "copy">({
-      message: "Install as symlink or copy?",
-      options: [
-        {
-          value: "symlink",
-          label: "Symlink",
-          hint: "stays in sync when klint updates",
-        },
-        {
-          value: "copy",
-          label: "Copy",
-          hint: "one-time snapshot, no ongoing dependency",
-        },
-      ],
-    });
-    if (clack.isCancel(mode)) {
-      clack.cancel("Cancelled.");
-      process.exit(0);
-    }
-    useSymlink = mode === "symlink";
-  }
-
-  const cwd = process.cwd();
-  const linkType = process.platform === "win32" ? "junction" : "dir";
-  for (const key of selectedAgents) {
-    const dest = resolve(cwd, AGENT_DIRS[key], "klint-rules");
-    mkdirSync(dirname(dest), { recursive: true });
-    try {
-      rmSync(dest, { recursive: true, force: true });
-    } catch {
-      /* already gone */
-    }
-    if (useSymlink) {
-      symlinkSync(relative(dirname(dest), skillSrc), dest, linkType);
-    } else {
-      cpSync(skillSrc, dest, { recursive: true });
-    }
-  }
-
-  if (process.stdin.isTTY) {
-    clack.outro("Done.");
-  }
-}
-
-function printHelp(): void {
-  const pluginRules = new Set(
-    Object.values(BUILT_IN_PLUGINS).flatMap((p) => Object.keys(p.rules))
-  );
-  const standaloneRules = Object.keys(BUILT_IN_RULES).filter((r) => !pluginRules.has(r));
-  const pluginEntries = Object.entries(BUILT_IN_PLUGINS);
-
-  process.stdout.write(
-    [
-      "klint — agent harness for TypeScript architecture rules",
-      "",
-      "Usage: klint [--config <dir>] [--rules <file>] [--engine ts|rust|compare|auto] [--fix] [--json]",
-      "       klint install-skill [--agents <list>] [--symlink | --copy]",
-      "",
-      "  --config <dir>   directory containing klint.yaml or klint.config.json (default: cwd)",
-      "  --rules  <file>  custom rules file (default: <configDir>/klint.rules.ts if present)",
-      "  --engine <name>  engine to use: ts (default), rust, compare, or auto (experimental)",
-      "  --fix            apply auto-fixes for fixable violations in-place",
-      "  --json           emit structured JSON to stdout (for agent/CI consumption)",
-      "  --debug          print file resolution and rule progress to stderr",
-      "",
-      "  install-skill    install the rule-authoring skill into agent config directories",
-      "                   --agents <list>  comma-separated: claude,opencode,cursor,codex (default: all)",
-      "                   --symlink        install as symlink (stays in sync with updates)",
-      "                   --copy           install as copy (default in non-TTY)",
-      "",
-      `Built-in rules (${standaloneRules.length}):`,
-      ...standaloneRules.map((r) => `  ${r}`),
-      "",
-      `Plugins (${pluginEntries.length}):`,
-      ...pluginEntries.flatMap(([name, plugin]) => [
-        `  ${name}`,
-        ...Object.keys(plugin.rules).map((r) => `    ${r}`),
-      ]),
-      "",
-    ].join("\n")
-  );
-}
-
 if (import.meta.main) await main();