@konvert7/klint 0.38.0 → 1.0.0

package/core/config.schema.ts

@@ -1,413 +0,0 @@
-import { z } from "zod";
-import { BUILT_IN_PLUGINS } from "../plugins/index";
-import { BUILT_IN_RULES } from "../rules/index";
-import type { KlintRule, RuleMeta } from "./types";
-
-const builtInRuleNames = Object.keys(BUILT_IN_RULES) as [string, ...string[]];
-const builtInPluginNames = Object.keys(BUILT_IN_PLUGINS) as [string, ...string[]];
-const pluginRuleNames = [
-  ...new Set(Object.values(BUILT_IN_PLUGINS).flatMap((p) => Object.keys(p.rules))),
-] as [string, ...string[]];
-const allKnownRuleNames = [...new Set([...builtInRuleNames, ...pluginRuleNames])] as [
-  string,
-  ...string[],
-];
-
-/** Look up a rule's implementation across BUILT_IN_RULES and plugin implementations. */
-function findRule(name: string): KlintRule | undefined {
-  if (BUILT_IN_RULES[name]) return BUILT_IN_RULES[name];
-  for (const plugin of Object.values(BUILT_IN_PLUGINS)) {
-    if (plugin.implementations[name]) return plugin.implementations[name];
-  }
-  return undefined;
-}
-
-function metaFor(name: string): RuleMeta | undefined {
-  return findRule(name)?.meta;
-}
-
-const SeveritySchema = z
-  .enum(["error", "warn", "off"])
-  .describe(
-    'Rule severity. "error" exits with code 2; "warn" reports but exits 0; "off" silences.'
-  );
-
-const RuleOptionsSchema = z
-  .object({
-    severity: SeveritySchema.optional(),
-    include: z
-      .array(z.string())
-      .optional()
-      .describe(
-        'Glob patterns scoping this rule to a subset of files. Prefix with ! to exclude. Example: ["src/hooks/**", "!src/hooks/scripts/**"]'
-      ),
-  })
-  .strict()
-  .describe(
-    'Rule options object. Omit severity to default to "error". Add include to scope the rule to specific files.'
-  );
-
-const RuleValueSchema = z.union([SeveritySchema, RuleOptionsSchema]);
-
-// ─── arch ─────────────────────────────────────────────────────────────
-
-const ArchSeveritySchema = z
-  .enum(["error", "warn"])
-  .describe(
-    'Severity for the arch rule. "error" exits with code 2; "warn" reports but exits 0. (arch rules cannot be "off" — remove the entry instead.)'
-  );
-
-const StringOrStringArray = z
-  .union([z.string(), z.array(z.string())])
-  .describe(
-    "Either a single layer name / glob pattern or an array of them. Layer names defined in `arch.layers` are resolved to their glob lists."
-  );
-
-const ArchLayersSchema = z
-  .record(z.string(), z.array(z.string()))
-  .describe(
-    "Named architectural zones. Keys are arbitrary layer names; values are glob patterns matching the files in that layer. Other arch rules reference these names instead of repeating globs."
-  )
-  .meta({
-    examples: [
-      'layers:\n  core:   ["src/hooks/lib/**", "src/tools/**"]\n  skills: ["assets/skills/**"]\n  dao:    ["src/dao/**"]',
-    ],
-  });
-
-const ArchImportRuleSchema = z
-  .object({
-    from: StringOrStringArray.describe(
-      "Source — a layer name or glob(s) for the files this rule applies to. Imports originating in `from` are checked against `deny`/`allow`."
-    ),
-    deny: StringOrStringArray.optional().describe(
-      "Layer name(s) or glob(s) the source is not allowed to import from. Mutually exclusive in spirit with `allow` (use one or the other)."
-    ),
-    allow: StringOrStringArray.optional().describe(
-      "Allowlist of layer name(s) / glob(s) the source may import from. Anything not matching `allow` is denied."
-    ),
-    "deny-packages": StringOrStringArray.optional().describe(
-      "Package specifier(s) the source is not allowed to import — npm packages, `node:` builtins, Python pip packages and stdlib modules, Swift system frameworks, external Rust crates, and C# namespaces or NuGet packages, which `deny`/`allow` cannot reach because they never resolve to a project file. Matching is per segment: `/` in TypeScript/JavaScript, so `next` also covers `next/headers` while `nextra` is unaffected; `.` in Python, Swift, and C#, so `os` also covers `os.path` while `oscrypto` is unaffected; and `::` in Rust, so `tokio` also covers `tokio::sync::Mutex` while `tokio_util` is unaffected. Python, Swift, Rust, and C# sources are checked by the Rust engine."
-    ),
-    "type-only": z
-      .literal("allow")
-      .optional()
-      .describe(
-        'When set to "allow", `import type` statements that would otherwise be denied are permitted. In Python, imports inside an `if TYPE_CHECKING:` block are exempted the same way. Useful for type-only references across layers.'
-      ),
-    message: z
-      .string()
-      .optional()
-      .describe(
-        "Custom error message reported when the rule is violated. Shown in the agent's event stream alongside file:line."
-      ),
-    severity: ArchSeveritySchema.optional(),
-  })
-  .strict()
-  .describe(
-    "An import-boundary rule. Restricts which layers a source can or cannot import from."
-  )
-  .meta({
-    examples: [
-      'arch:\n  imports:\n    - from: skills\n      deny: core\n      message: "Skills must be self-contained and portable"\n      severity: warn',
-      'arch:\n  imports:\n    - from: ["src/dao/**"]\n      allow: ["src/dao/**", "src/prisma/**", "src/types/**"]',
-    ],
-  });
-
-const ArchForbiddenPatternRuleSchema = z
-  .object({
-    pattern: z
-      .string()
-      .describe(
-        "Pattern to search for, scanned per line. A literal substring by default (e.g. a console logging call). Prefix with `re:` to match a regular expression instead (e.g. `re:\\bp-\\[\\d+px\\]`). Regexes must use the common JS/RE2 subset — no lookaround or backreferences — so the TS and Rust engines agree. Note: a literal pattern that itself begins with `re:` cannot be expressed; such a value is always read as a regex."
-      ),
-    in: StringOrStringArray.describe(
-      "Layer name(s) or glob(s) the pattern is forbidden in. Files outside the scope are not checked."
-    ),
-    message: z
-      .string()
-      .describe(
-        "Required error message explaining why the pattern is forbidden. Shown to the agent so it can fix the call site."
-      ),
-    severity: ArchSeveritySchema.optional(),
-  })
-  .strict();
-
-const ArchForbiddenJsxRuleSchema = z
-  .object({
-    "jsx-element": StringOrStringArray.describe(
-      "JSX intrinsic element name(s) to forbid (e.g. `button`, `input`, `label`). AST-matched on opening and self-closing tag names — robust to whitespace, attributes, and naming collisions like `<buttonGroup>`."
-    ),
-    in: StringOrStringArray.describe(
-      "Layer name(s) or glob(s) the element is forbidden in. Files outside the scope are not checked."
-    ),
-    message: z
-      .string()
-      .describe(
-        "Required error message explaining why the raw element is forbidden. Typically points at the design-system replacement (e.g. `Use <Button /> from @/components/ui/button`)."
-      ),
-    severity: ArchSeveritySchema.optional(),
-  })
-  .strict();
-
-const ArchForbiddenRuleSchema = z
-  .union([ArchForbiddenPatternRuleSchema, ArchForbiddenJsxRuleSchema])
-  .describe(
-    "A forbidden-pattern rule. Blocks either a literal substring (`pattern:`) or a JSX element (`jsx-element:`) inside specific layers."
-  )
-  .meta({
-    examples: [
-      'arch:\n  forbidden:\n    - pattern: "debugLog("\n      in: core\n      message: "Leaks into the agent event stream"',
-      'arch:\n  forbidden:\n    - jsx-element: ["button", "input", "label"]\n      in: ["src/app/**/*.tsx", "src/components/**/*.tsx", "!src/components/ui/**"]\n      message: "Use the design-system primitives in @/components/ui/* instead of raw HTML elements."',
-    ],
-  });
-
-const ArchSingletonPatternRuleSchema = z
-  .object({
-    pattern: z
-      .string()
-      .describe(
-        "Pattern whose appearance is allowed only at one location, scanned per line. A literal substring by default (e.g. `process.env.API_KEY`). Prefix with `re:` to match a regular expression instead. Regexes must use the common JS/RE2 subset — no lookaround or backreferences — so the TS and Rust engines agree. Note: a literal pattern that itself begins with `re:` cannot be expressed; such a value is always read as a regex."
-      ),
-    only: z
-      .string()
-      .describe(
-        "The single file path where this pattern is allowed. Every other occurrence becomes a violation."
-      ),
-    in: StringOrStringArray.optional().describe(
-      "Optional scope. Limit the scan to these layers/globs; defaults to all files in `include`."
-    ),
-    message: z.string(),
-    severity: ArchSeveritySchema.optional(),
-  })
-  .strict();
-
-const ArchSingletonJsxRuleSchema = z
-  .object({
-    "jsx-element": StringOrStringArray.describe(
-      "JSX intrinsic element name(s) allowed only inside the `only` file. AST-matched on tag names."
-    ),
-    only: z
-      .string()
-      .describe(
-        "The single file path where the element is allowed (typically the design-system primitive that wraps it)."
-      ),
-    in: StringOrStringArray.optional(),
-    message: z.string(),
-    severity: ArchSeveritySchema.optional(),
-  })
-  .strict();
-
-const ArchSingletonRuleSchema = z
-  .union([ArchSingletonPatternRuleSchema, ArchSingletonJsxRuleSchema])
-  .describe(
-    "A singleton-location rule. Pins a pattern or JSX element to exactly one file — the only honest way to enforce a module of record or a design-system primitive."
-  )
-  .meta({
-    examples: [
-      'arch:\n  singleton:\n    - pattern: "process.env.API_KEY"\n      only: "src/lib/auth.ts"\n      message: "API key access must funnel through the auth module."',
-      'arch:\n  singleton:\n    - jsx-element: "button"\n      only: "src/components/ui/button.tsx"\n      in: ["src/**/*.tsx"]\n      message: "Raw <button> belongs only to the Button primitive."',
-    ],
-  });
-
-const ArchMaxLinesRuleSchema = z
-  .object({
-    limit: z
-      .number()
-      .int()
-      .positive()
-      .describe(
-        "Maximum number of physical lines a file may contain. Counts every line including blanks and comments. A file with more lines than this is a violation."
-      ),
-    in: StringOrStringArray.describe(
-      "Layer name(s) or glob(s) the limit applies to. Files outside the scope are not checked."
-    ),
-    message: z
-      .string()
-      .optional()
-      .describe(
-        "Optional error message. Defaults to a message naming the limit (e.g. 'File exceeds the maximum of 300 lines')."
-      ),
-    severity: ArchSeveritySchema.optional(),
-  })
-  .strict()
-  .describe(
-    "A per-file line-count limit. Caps how long any file in scope may grow — the honest way to keep modules small without a formatter dependency."
-  )
-  .meta({
-    examples: [
-      'arch:\n  maxLines:\n    - limit: 300\n      in: src/**\n      message: "Split this module"',
-      "arch:\n  maxLines:\n    - limit: 300\n      in: src/**\n    - limit: 600\n      in: tests/**",
-    ],
-  });
-
-const CountDocCommentsSchema = z
-  .boolean()
-  .optional()
-  .describe(
-    "Count doc-comments toward the limit. Doc-comments are `/** … */` JSDoc blocks (TS/JS), `///` (Swift and C#), and `///` or `//!` (Rust); ordinary `//`, `/* */`, and `#` comments are always counted. Defaults to false, so documentation is exempt and only explanatory/inline comments are capped. Has no effect on Python: docstrings are string expressions rather than comments, so they never count toward either limit."
-  );
-
-const CommentIgnoreSchema = StringOrStringArray.optional().describe(
-  "Comment lines matching these patterns are structural, not prose — marker comments a build or codegen step reads, for example — and count toward neither limit. A literal substring by default; prefix with `re:` for a regex. Ignored lines still count in the density denominator (they are physical lines) and still hold a comment block together, so a marker cannot be used to split an over-tall block."
-);
-
-const ArchMaxCommentDensityRuleSchema = z
-  .object({
-    limit: z
-      .number()
-      .positive()
-      .max(100)
-      .describe(
-        "Maximum percentage of a file's physical lines that may be comment lines. Denominator is total physical lines (code + comments + blanks), the same count `maxLines` uses. A file above this ratio is a violation."
-      ),
-    countDocComments: CountDocCommentsSchema,
-    ignore: CommentIgnoreSchema,
-    in: StringOrStringArray.describe(
-      "Layer name(s) or glob(s) the limit applies to. Files outside the scope are not checked."
-    ),
-    message: z
-      .string()
-      .optional()
-      .describe(
-        "Optional error message. Defaults to a message naming the measured density and the limit."
-      ),
-    severity: ArchSeveritySchema.optional(),
-  })
-  .strict()
-  .describe(
-    "A per-file comment-density ceiling. Caps how much of a file may be explanatory comments — the honest way to push intent into code and names rather than prose (and to keep token cost down), while leaving doc-comments free by default."
-  )
-  .meta({
-    examples: [
-      'arch:\n  maxCommentDensity:\n    - limit: 5\n      in: src/**\n      message: "Encode intent in names, not comments"',
-      "arch:\n  maxCommentDensity:\n    - limit: 10\n      countDocComments: true\n      in: src/**",
-    ],
-  });
-
-const ArchMaxCommentBlockRuleSchema = z
-  .object({
-    limit: z
-      .number()
-      .int()
-      .positive()
-      .describe(
-        "Maximum number of consecutive comment lines allowed in a single block. A run of more comment lines than this — e.g. a tall comment stacked above a statement — is a violation, reported at the first offending line."
-      ),
-    countDocComments: CountDocCommentsSchema,
-    ignore: CommentIgnoreSchema,
-    in: StringOrStringArray.describe(
-      "Layer name(s) or glob(s) the limit applies to. Files outside the scope are not checked."
-    ),
-    message: z
-      .string()
-      .optional()
-      .describe(
-        "Optional error message. Defaults to a message naming the consecutive-line limit."
-      ),
-    severity: ArchSeveritySchema.optional(),
-  })
-  .strict()
-  .describe(
-    "A per-block comment-height cap. Limits how many comment lines may stack together, so comments stay terse and a long explanation becomes a well-named function instead. Doc-comments are exempt by default."
-  )
-  .meta({
-    examples: [
-      'arch:\n  maxCommentBlock:\n    - limit: 2\n      in: src/**\n      message: "Extract a named function instead of a comment block"',
-    ],
-  });
-
-const ArchSchema = z
-  .object({
-    layers: ArchLayersSchema.optional(),
-    imports: z
-      .array(ArchImportRuleSchema)
-      .optional()
-      .describe(
-        "Import-boundary rules. The dependency graph your README claims you have."
-      ),
-    forbidden: z
-      .array(ArchForbiddenRuleSchema)
-      .optional()
-      .describe("Forbidden-pattern rules. Block literal strings scoped to a layer."),
-    singleton: z
-      .array(ArchSingletonRuleSchema)
-      .optional()
-      .describe(
-        "Singleton-location rules. Pin a pattern to one file; every other touch is a violation."
-      ),
-    maxLines: z
-      .array(ArchMaxLinesRuleSchema)
-      .optional()
-      .describe(
-        "Per-file line-count limits. Cap how long files in a layer may grow, with different ceilings per scope."
-      ),
-    maxCommentDensity: z
-      .array(ArchMaxCommentDensityRuleSchema)
-      .optional()
-      .describe(
-        "Per-file comment-density ceilings. Cap the share of a file that may be explanatory comments; doc-comments are exempt by default."
-      ),
-    maxCommentBlock: z
-      .array(ArchMaxCommentBlockRuleSchema)
-      .optional()
-      .describe(
-        "Per-block comment-height caps. Limit how many comment lines may stack together; doc-comments are exempt by default."
-      ),
-  })
-  .strict()
-  .describe(
-    "Architecture-as-Code constraints — layers, import boundaries, forbidden patterns, singleton locations, comment budgets. Enforced by the arch engine alongside the rule set."
-  );
-
-function buildRulesSchema() {
-  const shape: Record<string, z.ZodType> = {};
-  for (const name of allKnownRuleNames) {
-    const meta = metaFor(name);
-    let entry: z.ZodType = RuleValueSchema.optional();
-    if (meta?.description) entry = entry.describe(meta.description);
-    if (meta?.examples?.length) entry = entry.meta({ examples: meta.examples });
-    shape[name] = entry;
-  }
-  return z.object(shape).catchall(RuleValueSchema);
-}
-
-export const KlintConfigSchema = z
-  .object({
-    $schema: z
-      .string()
-      .optional()
-      .describe(
-        "JSON Schema reference. Use ./klint.schema.json for local validation, or a version-tagged URL such as https://raw.githubusercontent.com/konvert7/klint/refs/tags/v0.29.0/klint.schema.json to pin the schema. A tagged URL naming a version other than the installed one raises a klint/schema-version warning."
-      ),
-    root: z
-      .string()
-      .optional()
-      .describe(
-        "Root directory used to resolve include paths and report relative file names. Defaults to the directory containing klint.config.json."
-      ),
-    include: z
-      .array(z.string())
-      .optional()
-      .describe(
-        'Glob patterns selecting which TypeScript files to lint. Prefix with ! to exclude. Defaults to ["."] which lints all .ts files under root. Example: ["src", "klint", "!**/node_modules/**"]'
-      ),
-    plugins: z
-      .array(z.enum(builtInPluginNames))
-      .optional()
-      .describe(
-        'Named rule bundles to enable. Each plugin applies a default set of rules at "error" severity. Individual rules from the bundle can be overridden or silenced via the rules map. Available: "sonar".'
-      ),
-    rules: buildRulesSchema()
-      .optional()
-      .describe(
-        'Map of rule name → severity or options. Example: { "no-floating-promise": "error", "no-sync-in-async": { "severity": "warn", "include": ["src/hooks/**"] } }.'
-      ),
-    arch: ArchSchema.optional(),
-  })
-  .strict()
-  .describe(
-    "klint configuration. Lives at klint.yaml (or klint.config.json) next to biome.json and knip.json."
-  );
-
-/** @lintignore */
-export type KlintConfigFile = z.infer<typeof KlintConfigSchema>;

package/core/fixer.ts

@@ -1,47 +0,0 @@
-import { readFileSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import type { Violation } from "./types";
-
-/**
- * Applies all fixable violations to their source files.
- * Fixes are applied bottom-to-top within each file to preserve line offsets.
- * Returns the number of fixes applied.
- */
-export function applyFixes(violations: Violation[], root: string): number {
-  const byFile = new Map<string, Violation[]>();
-  for (const v of violations) {
-    if (!v.fix) continue;
-    const abs = resolve(root, v.file);
-    const existing = byFile.get(abs) ?? [];
-    existing.push(v);
-    byFile.set(abs, existing);
-  }
-
-  let applied = 0;
-  for (const [absPath, fileViolations] of byFile) {
-    const lines = readFileSync(absPath, "utf-8").split("\n");
-    const sorted = [...fileViolations].sort(byLargestFixRangeFirst);
-
-    const used: Array<{ start: number; end: number }> = [];
-    for (const v of sorted) {
-      if (!v.fix) continue;
-      const { startLine, endLine, replacement } = v.fix;
-      if (used.some((r) => startLine <= r.end && endLine >= r.start)) continue;
-      lines.splice(startLine - 1, endLine - startLine + 1, ...replacement.split("\n"));
-      used.push({ start: startLine, end: endLine });
-      applied++;
-    }
-
-    writeFileSync(absPath, lines.join("\n"), "utf-8");
-  }
-
-  return applied;
-}
-
-/**
- * Largest-range fix wins: sorting by `endLine` descending applies fixes bottom-to-top
- * and lets an outer or overlapping fix beat inner ones that share a start position.
- */
-function byLargestFixRangeFirst(a: Violation, b: Violation): number {
-  return (b.fix?.endLine ?? 0) - (a.fix?.endLine ?? 0);
-}

package/core/native-binary.ts

@@ -1,123 +0,0 @@
-import { existsSync, readFileSync } 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;
-  readPackageJson?: (path: string) => { version?: string };
-  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,
-  readPackageJson = readJsonFile,
-  resolvePackageJson,
-}: NativeBinaryOptions): string | undefined {
-  const nativePackage = nativePackageForPlatform(platform, arch);
-  if (!nativePackage) return undefined;
-
-  const packageJsonPath = resolveOptionalPackageJson(
-    packageRoot,
-    nativePackage.packageName,
-    resolvePackageJson
-  );
-  if (!packageJsonPath) return undefined;
-  if (!nativePackageVersionMatches(packageRoot, packageJsonPath, readPackageJson)) {
-    return undefined;
-  }
-
-  const binaryPath = join(dirname(packageJsonPath), nativePackage.binaryPath);
-  return exists(binaryPath) ? binaryPath : undefined;
-}
-
-function nativePackageVersionMatches(
-  packageRoot: string,
-  nativePackageJsonPath: string,
-  readPackageJson: (path: string) => { version?: string }
-): boolean {
-  try {
-    const rootVersion = readPackageJson(join(packageRoot, "package.json")).version;
-    const nativeVersion = readPackageJson(nativePackageJsonPath).version;
-    if (!rootVersion || !nativeVersion) return true;
-    return rootVersion === nativeVersion;
-  } catch {
-    return true;
-  }
-}
-
-function readJsonFile(path: string): { version?: string } {
-  try {
-    return JSON.parse(readFileSync(path, "utf-8")) as { version?: string };
-  } catch {
-    return {};
-  }
-}
-
-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/core/paths.ts

@@ -1,9 +0,0 @@
-import { relative } from "node:path";
-
-export function toSlashPath(path: string): string {
-  return path.replaceAll("\\", "/");
-}
-
-export function relativeSlashPath(from: string, to: string): string {
-  return toSlashPath(relative(from, to));
-}

package/core/rule-helpers.ts

@@ -1,76 +0,0 @@
-import ts from "typescript";
-import { createProgram } from "./ast";
-import { relativeSlashPath } from "./paths";
-import type { KlintRule, RawViolation, RuleMeta } from "./types";
-import { defineRule } from "./types";
-
-export interface AstRuleContext {
-  sourceFile: ts.SourceFile;
-  checker: ts.TypeChecker;
-  root: string;
-  report(node: ts.Node, message: string): void;
-}
-
-export function defineAstRule(opts: {
-  meta: RuleMeta;
-  shouldRun?: (program: ts.Program) => boolean;
-  visit: (node: ts.Node, ctx: AstRuleContext) => void;
-}): KlintRule {
-  return defineRule({
-    meta: opts.meta,
-    check({ files, root }, violations) {
-      const program = createProgram(files, root);
-      if (opts.shouldRun && !opts.shouldRun(program)) return;
-      const checker = program.getTypeChecker();
-      const fileSet = new Set(files);
-
-      for (const sourceFile of program.getSourceFiles()) {
-        if (!fileSet.has(sourceFile.fileName) || sourceFile.isDeclarationFile) continue;
-
-        const ctx: AstRuleContext = {
-          sourceFile,
-          checker,
-          root,
-          report(node, message) {
-            const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-            violations.push({
-              file: relativeSlashPath(root, sourceFile.fileName),
-              line: line + 1,
-              message,
-            });
-          },
-        };
-
-        const walk = (node: ts.Node): void => {
-          opts.visit(node, ctx);
-          ts.forEachChild(node, walk);
-        };
-        walk(sourceFile);
-      }
-    },
-  });
-}
-
-/** Builds a single-node replacement fix preserving surrounding line text. */
-export function buildNodeReplacementFix(
-  src: ts.SourceFile,
-  node: ts.Node,
-  replacement: string
-): NonNullable<RawViolation["fix"]> {
-  const { line: startLine } = src.getLineAndCharacterOfPosition(node.getStart());
-  const { line: endLine } = src.getLineAndCharacterOfPosition(node.getEnd());
-  const lineStarts = src.getLineStarts();
-  const lineStart = lineStarts[startLine];
-  const lineEnd =
-    endLine + 1 < lineStarts.length ? lineStarts[endLine + 1] - 1 : src.text.length;
-  const linesText = src.text.slice(lineStart, lineEnd);
-  const nodeOffset = node.getStart() - lineStart;
-  const nodeEndOffset = node.getEnd() - lineStart;
-  const fixedLines =
-    linesText.slice(0, nodeOffset) + replacement + linesText.slice(nodeEndOffset);
-  return {
-    startLine: startLine + 1,
-    endLine: endLine + 1,
-    replacement: fixedLines,
-  };
-}