@konvert7/klint 0.5.0 → 0.7.0

package/core/arch.ts

@@ -196,23 +196,16 @@ export function runArchRules(
   for (const rule of arch.forbidden ?? []) {
     const severity: Severity = rule.severity ?? "error";
     const inFiles = resolveLayerFiles(rule.in, layers, root, allFiles);
-
-    for (const file of inFiles) {
-      const content = fileContents.get(file);
-      if (!content) continue;
-      const lines = content.split("\n");
-      for (let i = 0; i < lines.length; i++) {
-        if (lines[i].includes(rule.pattern)) {
-          violations.push({
-            file: relative(root, file).replaceAll("\\", "/"),
-            line: i + 1,
-            message: rule.message,
-            rule: "arch/forbidden",
-            severity,
-          });
-        }
-      }
-    }
+    scanLinesForPattern(
+      inFiles,
+      rule.pattern,
+      fileContents,
+      root,
+      "arch/forbidden",
+      rule.message,
+      severity,
+      violations
+    );
   }
 
   for (const rule of arch.singleton ?? []) {
@@ -222,24 +215,45 @@ export function runArchRules(
       ? resolveLayerFiles(rule.in, layers, root, allFiles)
       : allFiles;
     const scope = inFiles.filter((f) => f !== onlyFile);
+    scanLinesForPattern(
+      scope,
+      rule.pattern,
+      fileContents,
+      root,
+      "arch/singleton",
+      rule.message,
+      severity,
+      violations
+    );
+  }
 
-    for (const file of scope) {
-      const content = fileContents.get(file);
-      if (!content) continue;
-      const lines = content.split("\n");
-      for (let i = 0; i < lines.length; i++) {
-        if (lines[i].includes(rule.pattern)) {
-          violations.push({
-            file: relative(root, file).replaceAll("\\", "/"),
-            line: i + 1,
-            message: rule.message,
-            rule: "arch/singleton",
-            severity,
-          });
-        }
+  return violations;
+}
+
+function scanLinesForPattern(
+  files: string[],
+  pattern: string,
+  fileContents: Map<string, string>,
+  root: string,
+  ruleName: string,
+  message: string,
+  severity: Severity,
+  violations: Violation[]
+): void {
+  for (const file of files) {
+    const content = fileContents.get(file);
+    if (!content) continue;
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes(pattern)) {
+        violations.push({
+          file: relative(root, file).replaceAll("\\", "/"),
+          line: i + 1,
+          message,
+          rule: ruleName,
+          severity,
+        });
       }
     }
   }
-
-  return violations;
 }

package/core/rule-helpers.ts

@@ -0,0 +1,76 @@
+import { relative } from "node:path";
+import ts from "typescript";
+import { createProgram } from "./ast";
+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: relative(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,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konvert7/klint",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Architecture-as-Code linter for TypeScript. Enforce layer boundaries, import rules, and singleton patterns in YAML.",
   "type": "module",
   "bin": {
@@ -39,6 +39,7 @@
     "check-write": "biome check --write",
     "knip": "knip-bun",
     "klint": "bun cli.ts",
+    "jscpd": "jscpd --noTips",
     "schema": "bun tools/generate-schema.ts",
     "lint-staged": "lint-staged",
     "prepare": "bun .husky/install.mjs"
@@ -64,6 +65,7 @@
     "@types/bun": "latest",
     "@types/node": "latest",
     "husky": "^9.1.7",
+    "jscpd": "4.2.3",
     "knip": "^6.9.0",
     "lint-staged": "^15.5.2",
     "semantic-release": "^25.0.3"

package/plugins/sonar.ts

@@ -17,13 +17,11 @@ export const sonarPlugin: KlintPlugin = {
     "sonar/prefer-at": "error",
   },
   implementations: {
-    "sonar/prefer-string-replaceall": { check: preferStringReplaceall.check },
-    "sonar/prefer-string-raw-regexp": { check: preferStringRawRegexp.check },
-    "sonar/prefer-string-raw": { check: preferStringRaw.check },
-    "sonar/prefer-nullish-coalescing-assign": {
-      check: preferNullishCoalescingAssign.check,
-    },
-    "sonar/no-single-char-class": { check: noSingleCharClass.check },
-    "sonar/prefer-at": { check: preferAt.check },
+    "sonar/prefer-string-replaceall": preferStringReplaceall,
+    "sonar/prefer-string-raw-regexp": preferStringRawRegexp,
+    "sonar/prefer-string-raw": preferStringRaw,
+    "sonar/prefer-nullish-coalescing-assign": preferNullishCoalescingAssign,
+    "sonar/no-single-char-class": noSingleCharClass,
+    "sonar/prefer-at": preferAt,
   },
 };

package/rules/no-async-predicate.ts

@@ -1,62 +1,36 @@
-import { relative } from "node:path";
 import ts from "typescript";
-import { createProgram } from "../core/ast";
-import type { RawViolation } from "../core/types";
-import { defineRule } from "../core/types";
+import { defineAstRule } from "../core/rule-helpers";
 
 const PREDICATE_METHODS = new Set(["filter", "some", "every", "find", "findIndex"]);
 
-export const noAsyncPredicate = defineRule({
+export const noAsyncPredicate = defineAstRule({
   meta: {
     description:
       "Flags `async` functions passed to `.filter`/`.some`/`.every`/`.find`/`.findIndex`. Array methods coerce the returned promise to truthy, so every element appears to match.",
     examples: ["no-async-predicate: error"],
   },
-  check({ files, root }, violations) {
-    const program = createProgram(files, root);
-    const checker = program.getTypeChecker();
-    const fileSet = new Set(files);
+  visit(node, ctx) {
+    if (
+      !ts.isCallExpression(node) ||
+      !ts.isPropertyAccessExpression(node.expression) ||
+      !PREDICATE_METHODS.has(node.expression.name.text) ||
+      node.arguments.length === 0
+    )
+      return;
 
-    for (const sourceFile of program.getSourceFiles()) {
-      if (!fileSet.has(sourceFile.fileName) || sourceFile.isDeclarationFile) continue;
-      visitFile(sourceFile, checker, root, violations);
+    const receiverType = ctx.checker.getTypeAtLocation(node.expression.expression);
+    if (isArrayLike(receiverType) && isAsyncFunction(node.arguments[0])) {
+      const method = node.expression.name.text;
+      ctx.report(
+        node.arguments[0],
+        `Async callback passed to .${method}() — the returned Promise is always truthy, so the predicate never filters correctly. The array method cannot await it.`
+      );
     }
   },
 });
 
-function visitFile(
-  sourceFile: ts.SourceFile,
-  checker: ts.TypeChecker,
-  root: string,
-  violations: RawViolation[]
-): void {
-  function visit(node: ts.Node): void {
-    if (
-      ts.isCallExpression(node) &&
-      ts.isPropertyAccessExpression(node.expression) &&
-      PREDICATE_METHODS.has(node.expression.name.text) &&
-      node.arguments.length > 0
-    ) {
-      const receiverType = checker.getTypeAtLocation(node.expression.expression);
-      if (isArrayLike(receiverType, checker) && isAsyncFunction(node.arguments[0])) {
-        const method = node.expression.name.text;
-        const { line } = sourceFile.getLineAndCharacterOfPosition(
-          node.arguments[0].getStart()
-        );
-        violations.push({
-          file: relative(root, sourceFile.fileName),
-          line: line + 1,
-          message: `Async callback passed to .${method}() — the returned Promise is always truthy, so the predicate never filters correctly. The array method cannot await it.`,
-        });
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-}
-
-function isArrayLike(type: ts.Type, checker: ts.TypeChecker): boolean {
-  if (type.isUnion()) return type.types.some((t) => isArrayLike(t, checker));
+function isArrayLike(type: ts.Type): boolean {
+  if (type.isUnion()) return type.types.some((t) => isArrayLike(t));
   const sym = type.getSymbol();
   if (sym?.name === "Array" || sym?.name === "ReadonlyArray") return true;
   const ref = type as ts.TypeReference;

package/rules/no-date-equality.ts

@@ -1,58 +1,33 @@
-import { relative } from "node:path";
 import ts from "typescript";
-import { createProgram } from "../core/ast";
-import type { RawViolation } from "../core/types";
-import { defineRule } from "../core/types";
+import { defineAstRule } from "../core/rule-helpers";
 
-export const noDateEquality = defineRule({
+export const noDateEquality = defineAstRule({
   meta: {
     description:
       "Flags `Date` comparisons with `==`/`===`/`!=`/`!==` — these compare object identity, not the time value. Use `.getTime()` instead.",
     examples: ["no-date-equality: error"],
   },
-  check({ files, root }, violations) {
-    const program = createProgram(files, root);
-    const checker = program.getTypeChecker();
-    const fileSet = new Set(files);
+  visit(node, ctx) {
+    if (!ts.isBinaryExpression(node)) return;
+    const { kind } = node.operatorToken;
+    if (
+      kind !== ts.SyntaxKind.EqualsEqualsEqualsToken &&
+      kind !== ts.SyntaxKind.ExclamationEqualsEqualsToken
+    )
+      return;
 
-    for (const sourceFile of program.getSourceFiles()) {
-      if (!fileSet.has(sourceFile.fileName) || sourceFile.isDeclarationFile) continue;
-      visitFile(sourceFile, checker, root, violations);
+    const leftType = ctx.checker.getTypeAtLocation(node.left);
+    const rightType = ctx.checker.getTypeAtLocation(node.right);
+    if (isDateType(leftType) && isDateType(rightType)) {
+      const op = node.operatorToken.getText(ctx.sourceFile);
+      ctx.report(
+        node,
+        `Date values compared with ${op} — this compares object references, not time values. Use .getTime() or .valueOf() instead.`
+      );
     }
   },
 });
 
-function visitFile(
-  sourceFile: ts.SourceFile,
-  checker: ts.TypeChecker,
-  root: string,
-  violations: RawViolation[]
-): void {
-  function visit(node: ts.Node): void {
-    if (ts.isBinaryExpression(node)) {
-      const { kind } = node.operatorToken;
-      if (
-        kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
-        kind === ts.SyntaxKind.ExclamationEqualsEqualsToken
-      ) {
-        const leftType = checker.getTypeAtLocation(node.left);
-        const rightType = checker.getTypeAtLocation(node.right);
-        if (isDateType(leftType) && isDateType(rightType)) {
-          const op = node.operatorToken.getText(sourceFile);
-          const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-          violations.push({
-            file: relative(root, sourceFile.fileName),
-            line: line + 1,
-            message: `Date values compared with ${op} — this compares object references, not time values. Use .getTime() or .valueOf() instead.`,
-          });
-        }
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-}
-
 function isDateType(type: ts.Type): boolean {
   if (type.getSymbol()?.name === "Date") return true;
   if (type.isUnion()) return type.types.some(isDateType);

package/rules/no-floating-promise.ts

@@ -1,54 +1,28 @@
-import { relative } from "node:path";
 import ts from "typescript";
-import { createProgram } from "../core/ast";
-import type { RawViolation } from "../core/types";
-import { defineRule } from "../core/types";
+import { defineAstRule } from "../core/rule-helpers";
 
-export const noFloatingPromise = defineRule({
+export const noFloatingPromise = defineAstRule({
   meta: {
     description:
       "Flags Promise-returning expressions that aren't awaited or `.catch()`-handled — silent failures and unpredictable execution order.",
     examples: ["no-floating-promise: error"],
   },
-  check({ files, root }, violations) {
-    const program = createProgram(files, root);
-    const checker = program.getTypeChecker();
-    const fileSet = new Set(files);
-
-    for (const sourceFile of program.getSourceFiles()) {
-      if (!fileSet.has(sourceFile.fileName) || sourceFile.isDeclarationFile) continue;
-      visitFile(sourceFile, checker, root, violations);
-    }
-  },
-});
-
-function visitFile(
-  sourceFile: ts.SourceFile,
-  checker: ts.TypeChecker,
-  root: string,
-  violations: RawViolation[]
-): void {
-  function visit(node: ts.Node): void {
+  visit(node, ctx) {
     if (
       ts.isExpressionStatement(node) &&
       ts.isCallExpression(node.expression) &&
       !isHandled(node.expression)
     ) {
-      const type = checker.getTypeAtLocation(node.expression);
+      const type = ctx.checker.getTypeAtLocation(node.expression);
       if (isPromiseLike(type)) {
-        const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-        violations.push({
-          file: relative(root, sourceFile.fileName),
-          line: line + 1,
-          message:
-            "Promise-returning call is not awaited — errors will be silently discarded and execution order is unpredictable. Use await, void, or .catch().",
-        });
+        ctx.report(
+          node,
+          "Promise-returning call is not awaited — errors will be silently discarded and execution order is unpredictable. Use await, void, or .catch()."
+        );
       }
     }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-}
+  },
+});
 
 function isHandled(node: ts.CallExpression): boolean {
   if (!ts.isPropertyAccessExpression(node.expression)) return false;

package/rules/no-misused-promises.ts

@@ -1,63 +1,35 @@
-import { relative } from "node:path";
 import ts from "typescript";
-import { createProgram } from "../core/ast";
-import type { RawViolation } from "../core/types";
-import { defineRule } from "../core/types";
+import { defineAstRule } from "../core/rule-helpers";
 
-export const noMisusedPromises = defineRule({
+export const noMisusedPromises = defineAstRule({
   meta: {
     description:
       "Flags Promises passed where the type expects a non-thenable (e.g. an `if` condition, a `void` callback). The Promise's truthiness — not its resolved value — drives the branch.",
     examples: ["no-misused-promises: error"],
   },
-  check({ files, root }, violations) {
-    const program = createProgram(files, root);
-    const checker = program.getTypeChecker();
-    const fileSet = new Set(files);
-
-    for (const sourceFile of program.getSourceFiles()) {
-      if (!fileSet.has(sourceFile.fileName) || sourceFile.isDeclarationFile) continue;
-      visitFile(sourceFile, checker, root, violations);
+  visit(node, ctx) {
+    if (!ts.isCallExpression(node)) return;
+    const sig = ctx.checker.getResolvedSignature(node);
+    if (!sig) return;
+    const params = sig.getParameters();
+    for (let i = 0; i < node.arguments.length; i++) {
+      const arg = node.arguments[i];
+      if (!isAsyncFunction(arg)) continue;
+
+      const param = params[Math.min(i, params.length - 1)];
+      if (!param) continue;
+
+      const paramType = ctx.checker.getTypeOfSymbolAtLocation(param, node);
+      if (expectsSyncCallback(paramType, ctx.checker)) {
+        ctx.report(
+          arg,
+          "Async function passed where a sync callback is expected — the caller cannot await it and errors will be silently lost."
+        );
+      }
     }
   },
 });
 
-function visitFile(
-  sourceFile: ts.SourceFile,
-  checker: ts.TypeChecker,
-  root: string,
-  violations: RawViolation[]
-): void {
-  function visit(node: ts.Node): void {
-    if (ts.isCallExpression(node)) {
-      const sig = checker.getResolvedSignature(node);
-      if (sig) {
-        const params = sig.getParameters();
-        for (let i = 0; i < node.arguments.length; i++) {
-          const arg = node.arguments[i];
-          if (!isAsyncFunction(arg)) continue;
-
-          const param = params[Math.min(i, params.length - 1)];
-          if (!param) continue;
-
-          const paramType = checker.getTypeOfSymbolAtLocation(param, node);
-          if (expectsSyncCallback(paramType, checker)) {
-            const { line } = sourceFile.getLineAndCharacterOfPosition(arg.getStart());
-            violations.push({
-              file: relative(root, sourceFile.fileName),
-              line: line + 1,
-              message:
-                "Async function passed where a sync callback is expected — the caller cannot await it and errors will be silently lost.",
-            });
-          }
-        }
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-}
-
 function isAsyncFunction(
   node: ts.Node
 ): node is ts.ArrowFunction | ts.FunctionExpression {

package/rules/no-object-in-template.ts

@@ -1,8 +1,5 @@
-import { relative } from "node:path";
 import ts from "typescript";
-import { createProgram } from "../core/ast";
-import type { RawViolation } from "../core/types";
-import { defineRule } from "../core/types";
+import { defineAstRule } from "../core/rule-helpers";
 
 // Builtins with a meaningful toString() that isn't [object Object]
 const SAFE_SYMBOL_NAMES = new Set([
@@ -21,52 +18,26 @@ const SAFE_SYMBOL_NAMES = new Set([
   "Symbol",
 ]);
 
-export const noObjectInTemplate = defineRule({
+export const noObjectInTemplate = defineAstRule({
   meta: {
     description:
       "Flags non-primitive objects interpolated into template literals — produces `[object Object]` unless `toString()` is overridden.",
     examples: ["no-object-in-template: error"],
   },
-  check({ files, root }, violations) {
-    const program = createProgram(files, root);
-    const checker = program.getTypeChecker();
-    const fileSet = new Set(files);
-
-    for (const sourceFile of program.getSourceFiles()) {
-      if (!fileSet.has(sourceFile.fileName) || sourceFile.isDeclarationFile) continue;
-      visitFile(sourceFile, checker, root, violations);
+  visit(node, ctx) {
+    if (!ts.isTemplateExpression(node)) return;
+    for (const span of node.templateSpans) {
+      const type = ctx.checker.getTypeAtLocation(span.expression);
+      if (wouldRenderAsObjectObject(type, ctx.checker)) {
+        ctx.report(
+          span.expression,
+          "Object interpolated in template literal has no custom toString() — it will render as [object Object]. Access a specific property or implement toString()."
+        );
+      }
     }
   },
 });
 
-function visitFile(
-  sourceFile: ts.SourceFile,
-  checker: ts.TypeChecker,
-  root: string,
-  violations: RawViolation[]
-): void {
-  function visit(node: ts.Node): void {
-    if (ts.isTemplateExpression(node)) {
-      for (const span of node.templateSpans) {
-        const type = checker.getTypeAtLocation(span.expression);
-        if (wouldRenderAsObjectObject(type, checker)) {
-          const { line } = sourceFile.getLineAndCharacterOfPosition(
-            span.expression.getStart()
-          );
-          violations.push({
-            file: relative(root, sourceFile.fileName),
-            line: line + 1,
-            message:
-              "Object interpolated in template literal has no custom toString() — it will render as [object Object]. Access a specific property or implement toString().",
-          });
-        }
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-}
-
 function wouldRenderAsObjectObject(type: ts.Type, checker: ts.TypeChecker): boolean {
   const primitiveFlags =
     ts.TypeFlags.String |

package/rules/no-optional-chain-on-non-nullable.ts

@@ -1,53 +1,27 @@
-import { relative } from "node:path";
 import ts from "typescript";
-import { createProgram } from "../core/ast";
-import type { RawViolation } from "../core/types";
-import { defineRule } from "../core/types";
+import { defineAstRule } from "../core/rule-helpers";
 
-export const noOptionalChainOnNonNullable = defineRule({
+export const noOptionalChainOnNonNullable = defineAstRule({
   meta: {
     description:
       "Flags `?.` on receivers whose static type cannot be `null` or `undefined`. The optional chain is dead code and obscures the real shape.",
     examples: ["no-optional-chain-on-non-nullable: warn"],
   },
-  check({ files, root }, violations) {
-    const program = createProgram(files, root);
-    const checker = program.getTypeChecker();
-
-    if (!program.getCompilerOptions().strictNullChecks) return;
-
-    const fileSet = new Set(files);
-    for (const sourceFile of program.getSourceFiles()) {
-      if (!fileSet.has(sourceFile.fileName) || sourceFile.isDeclarationFile) continue;
-      visitFile(sourceFile, checker, root, violations);
-    }
+  shouldRun(program) {
+    return program.getCompilerOptions().strictNullChecks === true;
   },
-});
-
-function visitFile(
-  sourceFile: ts.SourceFile,
-  checker: ts.TypeChecker,
-  root: string,
-  violations: RawViolation[]
-): void {
-  function visit(node: ts.Node): void {
+  visit(node, ctx) {
     const receiver = getOptionalChainReceiver(node);
-    if (receiver) {
-      const type = checker.getTypeAtLocation(receiver);
-      if (!isNullable(type)) {
-        const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-        violations.push({
-          file: relative(root, sourceFile.fileName),
-          line: line + 1,
-          message:
-            "Optional chain (?.) on a non-nullable type — the receiver can never be null or undefined here. Use . to remove misleading dead code.",
-        });
-      }
+    if (!receiver) return;
+    const type = ctx.checker.getTypeAtLocation(receiver);
+    if (!isNullable(type)) {
+      ctx.report(
+        node,
+        "Optional chain (?.) on a non-nullable type — the receiver can never be null or undefined here. Use . to remove misleading dead code."
+      );
     }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-}
+  },
+});
 
 function getOptionalChainReceiver(node: ts.Node): ts.Expression | undefined {
   if (

package/rules/no-single-char-class.ts

@@ -1,6 +1,7 @@
 import { relative } from "node:path";
 import ts from "typescript";
 import { walkAst } from "../core/ast";
+import { buildNodeReplacementFix } from "../core/rule-helpers";
 import type { KlintRule } from "../core/types";
 
 // Unescaped metacharacters that lose their special meaning inside a character class,
@@ -95,27 +96,13 @@ export const noSingleCharClass: KlintRule = {
         fixedPattern += pattern.slice(prev);
 
         const fixedRegex = `/${fixedPattern}/${flags}`;
-        const { line } = src.getLineAndCharacterOfPosition(node.getStart());
-        const { line: endLine } = src.getLineAndCharacterOfPosition(node.getEnd());
-        const lineStarts = src.getLineStarts();
-        const lineStart = lineStarts[line];
-        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) + fixedRegex + linesText.slice(nodeEndOffset);
+        const fix = buildNodeReplacementFix(src, node, fixedRegex);
 
         violations.push({
           file: relative(root, file),
-          line: line + 1,
+          line: fix.startLine,
           message: `Character class [${toFix[0].inner}] contains a single element — remove the brackets.`,
-          fix: {
-            startLine: line + 1,
-            endLine: endLine + 1,
-            replacement: fixedLines,
-          },
+          fix,
         });
       });
     }

package/rules/prefer-at.ts

@@ -1,6 +1,7 @@
 import { relative } from "node:path";
 import ts from "typescript";
 import { walkAst } from "../core/ast";
+import { buildNodeReplacementFix } from "../core/rule-helpers";
 import type { KlintRule } from "../core/types";
 
 export const preferAt: KlintRule = {
@@ -31,27 +32,13 @@ export const preferAt: KlintRule = {
         if (baseText !== arg.left.expression.getText(src)) return;
 
         const fixedCall = `${baseText}.at(-${n})`;
-        const { line } = src.getLineAndCharacterOfPosition(node.getStart());
-        const { line: endLine } = src.getLineAndCharacterOfPosition(node.getEnd());
-        const lineStarts = src.getLineStarts();
-        const lineStart = lineStarts[line];
-        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) + fixedCall + linesText.slice(nodeEndOffset);
+        const fix = buildNodeReplacementFix(src, node, fixedCall);
 
         violations.push({
           file: relative(root, file),
-          line: line + 1,
+          line: fix.startLine,
           message: `Prefer ${baseText}.at(-${n}) over ${baseText}[${baseText}.length - ${n}] for cleaner negative indexing.`,
-          fix: {
-            startLine: line + 1,
-            endLine: endLine + 1,
-            replacement: fixedLines,
-          },
+          fix,
         });
       });
     }

package/rules/prefer-string-raw.ts

@@ -1,6 +1,7 @@
 import { relative } from "node:path";
 import ts from "typescript";
 import { walkAst } from "../core/ast";
+import { buildNodeReplacementFix } from "../core/rule-helpers";
 import type { KlintRule } from "../core/types";
 
 export const preferStringRaw: KlintRule = {
@@ -22,29 +23,15 @@ export const preferStringRaw: KlintRule = {
         // Can't embed backtick, ${ (would start interpolation), or trailing \ (would escape closing backtick)
         if (value.includes("`") || value.includes("${") || value.endsWith("\\")) return;
 
-        const { line } = src.getLineAndCharacterOfPosition(node.getStart());
-        const { line: endLine } = src.getLineAndCharacterOfPosition(node.getEnd());
-        const lineStarts = src.getLineStarts();
-        const lineStart = lineStarts[line];
-        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 fixedNode = `String.raw\`${value}\``;
-        const fixedLines =
-          linesText.slice(0, nodeOffset) + fixedNode + linesText.slice(nodeEndOffset);
+        const fix = buildNodeReplacementFix(src, node, fixedNode);
 
         violations.push({
           file: relative(root, file),
-          line: line + 1,
+          line: fix.startLine,
           message:
             "String literal with escaped backslashes — use String.raw`...` for clarity (Sonar S6535).",
-          fix: {
-            startLine: line + 1,
-            endLine: endLine + 1,
-            replacement: fixedLines,
-          },
+          fix,
         });
       });
     }

package/rules/prefer-string-replaceall.ts

@@ -1,6 +1,7 @@
 import { relative } from "node:path";
 import ts from "typescript";
 import { walkAst } from "../core/ast";
+import { buildNodeReplacementFix } from "../core/rule-helpers";
 import type { KlintRule } from "../core/types";
 
 export const preferStringReplaceall: KlintRule = {
@@ -37,28 +38,13 @@ export const preferStringReplaceall: KlintRule = {
           ? `'${pattern.replaceAll("'", "\\'")}'`
           : `"${pattern}"`;
         const fixedCall = `${strText}.replaceAll(${patternLit}, ${replacementText})`;
-
-        const { line: s } = src.getLineAndCharacterOfPosition(node.getStart());
-        const { line: e } = src.getLineAndCharacterOfPosition(node.getEnd());
-        const lineStarts = src.getLineStarts();
-        const lineStart = lineStarts[s];
-        const lineEnd =
-          e + 1 < lineStarts.length ? lineStarts[e + 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) + fixedCall + linesText.slice(nodeEndOffset);
+        const fix = buildNodeReplacementFix(src, node, fixedCall);
 
         violations.push({
           file: relative(root, file),
-          line: s + 1,
+          line: fix.startLine,
           message: `Prefer \`${strText}.replaceAll(${patternLit}, ...)\` over \`.replace(/${pattern}/g, ...)\` — replaceAll() with a string is clearer and avoids regex escaping pitfalls.`,
-          fix: {
-            startLine: s + 1,
-            endLine: e + 1,
-            replacement: fixedLines,
-          },
+          fix,
         });
       });
     }