@alexgorbatchev/typescript-ai-policy 1.0.2 → 1.0.4

package/src/semantic-fixes/applyTextEdits.ts

@@ -1,20 +1,20 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import ts from "typescript";
-import type { ITextEdit } from "./types.ts";
+import type { TextEdit } from "./types.ts";
 
-type IOffsetTextEdit = {
+type OffsetTextEdit = {
   endOffset: number;
   newText: string;
   startOffset: number;
 };
 
-type IFileEditEntry = {
+type FileEditEntry = {
   filePath: string;
-  textEdits: readonly ITextEdit[];
+  textEdits: readonly TextEdit[];
 };
 
-function readFileEditEntries(textEdits: readonly ITextEdit[]): readonly IFileEditEntry[] {
-  const textEditsByFilePath = new Map<string, ITextEdit[]>();
+function readFileEditEntries(textEdits: readonly TextEdit[]): readonly FileEditEntry[] {
+  const textEditsByFilePath = new Map<string, TextEdit[]>();
 
   for (const textEdit of textEdits) {
     const existingTextEdits = textEditsByFilePath.get(textEdit.filePath);
@@ -32,7 +32,7 @@ function readFileEditEntries(textEdits: readonly ITextEdit[]): readonly IFileEdi
   }));
 }
 
-function compareOffsetTextEditsAscending(left: IOffsetTextEdit, right: IOffsetTextEdit): number {
+function compareOffsetTextEditsAscending(left: OffsetTextEdit, right: OffsetTextEdit): number {
   if (left.startOffset !== right.startOffset) {
     return left.startOffset - right.startOffset;
   }
@@ -44,7 +44,7 @@ function compareOffsetTextEditsAscending(left: IOffsetTextEdit, right: IOffsetTe
   return left.newText.localeCompare(right.newText);
 }
 
-function compareOffsetTextEditsDescending(left: IOffsetTextEdit, right: IOffsetTextEdit): number {
+function compareOffsetTextEditsDescending(left: OffsetTextEdit, right: OffsetTextEdit): number {
   return compareOffsetTextEditsAscending(right, left);
 }
 
@@ -53,7 +53,7 @@ function readOffset(positionContent: string, line: number, character: number): n
   return ts.getPositionOfLineAndCharacter(sourceFile, line, character);
 }
 
-function readOffsetTextEdit(content: string, textEdit: ITextEdit): IOffsetTextEdit {
+function readOffsetTextEdit(content: string, textEdit: TextEdit): OffsetTextEdit {
   return {
     endOffset: readOffset(content, textEdit.end.line, textEdit.end.character),
     newText: textEdit.newText,
@@ -61,31 +61,31 @@ function readOffsetTextEdit(content: string, textEdit: ITextEdit): IOffsetTextEd
   };
 }
 
-function haveSameRange(left: IOffsetTextEdit, right: IOffsetTextEdit): boolean {
+function haveSameRange(left: OffsetTextEdit, right: OffsetTextEdit): boolean {
   return left.startOffset === right.startOffset && left.endOffset === right.endOffset;
 }
 
-function isInsertion(edit: IOffsetTextEdit): boolean {
+function isInsertion(edit: OffsetTextEdit): boolean {
   return edit.startOffset === edit.endOffset;
 }
 
-function haveSameInsertionPoint(left: IOffsetTextEdit, right: IOffsetTextEdit): boolean {
+function haveSameInsertionPoint(left: OffsetTextEdit, right: OffsetTextEdit): boolean {
   return isInsertion(left) && isInsertion(right) && left.startOffset === right.startOffset;
 }
 
-function rangesOverlap(left: IOffsetTextEdit, right: IOffsetTextEdit): boolean {
+function rangesOverlap(left: OffsetTextEdit, right: OffsetTextEdit): boolean {
   return left.startOffset < right.endOffset && right.startOffset < left.endOffset;
 }
 
-function containsRange(container: IOffsetTextEdit, candidate: IOffsetTextEdit): boolean {
+function containsRange(container: OffsetTextEdit, candidate: OffsetTextEdit): boolean {
   return container.startOffset <= candidate.startOffset && container.endOffset >= candidate.endOffset;
 }
 
 function readNormalizedOffsetTextEdits(
   filePath: string,
-  offsetTextEdits: readonly IOffsetTextEdit[],
-): readonly IOffsetTextEdit[] {
-  const normalizedOffsetTextEdits: IOffsetTextEdit[] = [];
+  offsetTextEdits: readonly OffsetTextEdit[],
+): readonly OffsetTextEdit[] {
+  const normalizedOffsetTextEdits: OffsetTextEdit[] = [];
 
   for (const offsetTextEdit of [...offsetTextEdits].sort(compareOffsetTextEditsAscending)) {
     const previousOffsetTextEdit = normalizedOffsetTextEdits.at(-1);
@@ -123,7 +123,7 @@ function readNormalizedOffsetTextEdits(
   return normalizedOffsetTextEdits;
 }
 
-export function readUpdatedContent(filePath: string, content: string, textEdits: readonly ITextEdit[]): string {
+export function readUpdatedContent(filePath: string, content: string, textEdits: readonly TextEdit[]): string {
   const offsetTextEdits = [
     ...readNormalizedOffsetTextEdits(
       filePath,
@@ -143,7 +143,7 @@ export function readUpdatedContent(filePath: string, content: string, textEdits:
   return updatedContent;
 }
 
-function applyFileTextEdits(filePath: string, textEdits: readonly ITextEdit[]): void {
+function applyFileTextEdits(filePath: string, textEdits: readonly TextEdit[]): void {
   const content = readFileSync(filePath, "utf8");
   const updatedContent = readUpdatedContent(filePath, content, textEdits);
 
@@ -152,7 +152,7 @@ function applyFileTextEdits(filePath: string, textEdits: readonly ITextEdit[]):
   }
 }
 
-export function applyTextEdits(textEdits: readonly ITextEdit[]): readonly string[] {
+export function applyTextEdits(textEdits: readonly TextEdit[]): readonly string[] {
   const changedFilePaths: string[] = [];
 
   for (const fileEditEntry of readFileEditEntries(textEdits)) {

package/src/semantic-fixes/backends/tsgo-lsp/TsgoLspClient.ts

@@ -1,95 +1,95 @@
 import { spawn } from "node:child_process";
 import { once } from "node:events";
 import { pathToFileURL } from "node:url";
-import type { ILineAndCharacter } from "../../types.ts";
+import type { LineAndCharacter } from "../../types.ts";
 
-type IJsonRpcIdentifier = number | string | null;
+type JsonRpcIdentifier = number | string | null;
 
-type IJsonRpcError = {
+type JsonRpcError = {
   code: number;
   message: string;
 };
 
-type IJsonRpcErrorResponse = {
-  error: IJsonRpcError;
-  id: IJsonRpcIdentifier;
+type JsonRpcErrorResponse = {
+  error: JsonRpcError;
+  id: JsonRpcIdentifier;
   jsonrpc: string;
 };
 
-type IJsonRpcRequestMessage = {
-  id?: IJsonRpcIdentifier;
+type JsonRpcRequestMessage = {
+  id?: JsonRpcIdentifier;
   jsonrpc: string;
   method: string;
   params?: unknown;
 };
 
-type IJsonRpcSuccessResponse = {
-  id: IJsonRpcIdentifier;
+type JsonRpcSuccessResponse = {
+  id: JsonRpcIdentifier;
   jsonrpc: string;
   result?: unknown;
 };
 
-type IJsonRpcResponse = IJsonRpcErrorResponse | IJsonRpcSuccessResponse;
+type JsonRpcResponse = JsonRpcErrorResponse | JsonRpcSuccessResponse;
 
-type ILspTextDocumentIdentifier = {
+type LspTextDocumentIdentifier = {
   uri: string;
 };
 
-type ILspPosition = {
+type LspPosition = {
   character: number;
   line: number;
 };
 
-type ILspWorkspaceFolder = {
+type LspWorkspaceFolder = {
   name: string;
   uri: string;
 };
 
-type ILspWorkspaceEditCapabilities = {
+type LspWorkspaceEditCapabilities = {
   documentChanges: boolean;
 };
 
-type ILspWorkspaceCapabilities = {
-  workspaceEdit: ILspWorkspaceEditCapabilities;
+type LspWorkspaceCapabilities = {
+  workspaceEdit: LspWorkspaceEditCapabilities;
 };
 
-type ILspRenameCapabilities = {
+type LspRenameCapabilities = {
   prepareSupport: boolean;
 };
 
-type ILspTextDocumentCapabilities = {
-  rename: ILspRenameCapabilities;
+type LspTextDocumentCapabilities = {
+  rename: LspRenameCapabilities;
 };
 
-type ILspClientCapabilities = {
-  textDocument: ILspTextDocumentCapabilities;
-  workspace: ILspWorkspaceCapabilities;
+type LspClientCapabilities = {
+  textDocument: LspTextDocumentCapabilities;
+  workspace: LspWorkspaceCapabilities;
 };
 
-type ILspInitializeParams = {
-  capabilities: ILspClientCapabilities;
+type LspInitializeParams = {
+  capabilities: LspClientCapabilities;
   processId: number;
   rootUri: string;
-  workspaceFolders: readonly ILspWorkspaceFolder[];
+  workspaceFolders: readonly LspWorkspaceFolder[];
 };
 
-type ILspPrepareRenameParams = {
-  position: ILspPosition;
-  textDocument: ILspTextDocumentIdentifier;
+type LspPrepareRenameParams = {
+  position: LspPosition;
+  textDocument: LspTextDocumentIdentifier;
 };
 
-type ILspRenameParams = {
+type LspRenameParams = {
   newName: string;
-  position: ILspPosition;
-  textDocument: ILspTextDocumentIdentifier;
+  position: LspPosition;
+  textDocument: LspTextDocumentIdentifier;
 };
 
-type ITsgoLspClientOptions = {
+type TsgoLspClientOptions = {
   tsgoExecutablePath: string;
   workspacePath: string;
 };
 
-type IPendingRequest = {
+type PendingRequest = {
   reject: (error: Error) => void;
   resolve: (result: unknown) => void;
 };
@@ -98,7 +98,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null;
 }
 
-function isJsonRpcError(value: unknown): value is IJsonRpcError {
+function isJsonRpcError(value: unknown): value is JsonRpcError {
   if (!isRecord(value)) {
     return false;
   }
@@ -106,7 +106,7 @@ function isJsonRpcError(value: unknown): value is IJsonRpcError {
   return typeof value.code === "number" && typeof value.message === "string";
 }
 
-function isJsonRpcRequestMessage(value: unknown): value is IJsonRpcRequestMessage {
+function isJsonRpcRequestMessage(value: unknown): value is JsonRpcRequestMessage {
   if (!isRecord(value)) {
     return false;
   }
@@ -114,7 +114,7 @@ function isJsonRpcRequestMessage(value: unknown): value is IJsonRpcRequestMessag
   return value.jsonrpc === "2.0" && typeof value.method === "string";
 }
 
-function isJsonRpcResponse(value: unknown): value is IJsonRpcResponse {
+function isJsonRpcResponse(value: unknown): value is JsonRpcResponse {
   if (!isRecord(value)) {
     return false;
   }
@@ -135,7 +135,7 @@ function isJsonRpcResponse(value: unknown): value is IJsonRpcResponse {
   return Reflect.has(value, "result");
 }
 
-function readLspPosition(position: ILineAndCharacter): ILspPosition {
+function readLspPosition(position: LineAndCharacter): LspPosition {
   return {
     character: position.character,
     line: position.line,
@@ -143,13 +143,13 @@ function readLspPosition(position: ILineAndCharacter): ILspPosition {
 }
 
 export class TsgoLspClient {
-  private readonly pendingRequests = new Map<number, IPendingRequest>();
+  private readonly pendingRequests = new Map<number, PendingRequest>();
   private readonly process: ReturnType<typeof spawn>;
   private readonly stderrChunks: string[] = [];
   private stdoutBuffer = Buffer.alloc(0);
   private requestId = 0;
 
-  public constructor(private readonly options: ITsgoLspClientOptions) {
+  public constructor(private readonly options: TsgoLspClientOptions) {
     this.process = spawn(this.options.tsgoExecutablePath, ["--lsp", "--stdio"], {
       cwd: this.options.workspacePath,
       stdio: ["pipe", "pipe", "pipe"],
@@ -187,7 +187,7 @@ export class TsgoLspClient {
 
   public async initialize(): Promise<void> {
     const rootUri = pathToFileURL(this.options.workspacePath).toString();
-    const initializeParams: ILspInitializeParams = {
+    const initializeParams: LspInitializeParams = {
       capabilities: {
         textDocument: {
           rename: {
@@ -214,8 +214,8 @@ export class TsgoLspClient {
     this.sendNotification("initialized");
   }
 
-  public prepareRename(filePath: string, position: ILineAndCharacter): Promise<unknown> {
-    const params: ILspPrepareRenameParams = {
+  public prepareRename(filePath: string, position: LineAndCharacter): Promise<unknown> {
+    const params: LspPrepareRenameParams = {
       position: readLspPosition(position),
       textDocument: {
         uri: pathToFileURL(filePath).toString(),
@@ -225,8 +225,8 @@ export class TsgoLspClient {
     return this.sendRequest("textDocument/prepareRename", params);
   }
 
-  public rename(filePath: string, position: ILineAndCharacter, newName: string): Promise<unknown> {
-    const params: ILspRenameParams = {
+  public rename(filePath: string, position: LineAndCharacter, newName: string): Promise<unknown> {
+    const params: LspRenameParams = {
       newName,
       position: readLspPosition(position),
       textDocument: {
@@ -289,7 +289,7 @@ export class TsgoLspClient {
     }
   }
 
-  private handleResponse(message: IJsonRpcResponse): void {
+  private handleResponse(message: JsonRpcResponse): void {
     if (typeof message.id !== "number") {
       return;
     }
@@ -309,7 +309,7 @@ export class TsgoLspClient {
     pendingRequest.resolve(message.result ?? null);
   }
 
-  private handleServerRequest(message: IJsonRpcRequestMessage): void {
+  private handleServerRequest(message: JsonRpcRequestMessage): void {
     if (message.id === undefined) {
       return;
     }
@@ -401,7 +401,7 @@ export class TsgoLspClient {
     clearTimeout(killTimer);
   }
 
-  private writeMessage(method: string, id?: IJsonRpcIdentifier, params?: unknown): void {
+  private writeMessage(method: string, id?: JsonRpcIdentifier, params?: unknown): void {
     const message: Record<string, unknown> = {
       jsonrpc: "2.0",
       method,
@@ -418,7 +418,7 @@ export class TsgoLspClient {
     this.writeSerializedMessage(message);
   }
 
-  private writeResponse(id: IJsonRpcIdentifier, result: unknown): void {
+  private writeResponse(id: JsonRpcIdentifier, result: unknown): void {
     this.writeSerializedMessage({
       id,
       jsonrpc: "2.0",

package/src/semantic-fixes/backends/tsgo-lsp/createTsgoLspSemanticFixBackend.ts

@@ -3,46 +3,46 @@ import { fileURLToPath } from "node:url";
 import { readMovedFileTextEdits } from "../../readMovedFileTextEdits.ts";
 import { TsgoLspClient } from "./TsgoLspClient.ts";
 import type {
-  IApplySemanticFixesOptions,
-  IFileMove,
-  IMoveFileOperation,
-  ISemanticFixBackend,
-  ISemanticFixBackendContext,
-  ISemanticFixOperation,
-  ISemanticFixPlan,
-  ISemanticFixPlanResult,
-  ISymbolRenameOperation,
-  ITextEdit,
+  ApplySemanticFixesOptions,
+  FileMove,
+  MoveFileOperation,
+  SemanticFixBackend,
+  SemanticFixBackendContext,
+  SemanticFixOperation,
+  SemanticFixPlan,
+  SemanticFixPlanResult,
+  SymbolRenameOperation,
+  TextEdit,
 } from "../../types.ts";
 
-type ILspPosition = {
+type LspPosition = {
   character: number;
   line: number;
 };
 
-type ILspRange = {
-  end: ILspPosition;
-  start: ILspPosition;
+type LspRange = {
+  end: LspPosition;
+  start: LspPosition;
 };
 
-type ILspTextEdit = {
+type LspTextEdit = {
   newText: string;
-  range: ILspRange;
+  range: LspRange;
 };
 
-type ILspWorkspaceChanges = Record<string, readonly ILspTextEdit[]>;
+type LspWorkspaceChanges = Record<string, readonly LspTextEdit[]>;
 
-type ILspWorkspaceEdit = {
-  changes: ILspWorkspaceChanges;
+type LspWorkspaceEdit = {
+  changes: LspWorkspaceChanges;
 };
 
-type IClientCache = Map<string, TsgoLspClient>;
+type ClientCache = Map<string, TsgoLspClient>;
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null;
 }
 
-function isLspPosition(value: unknown): value is ILspPosition {
+function isLspPosition(value: unknown): value is LspPosition {
   if (!isRecord(value)) {
     return false;
   }
@@ -50,7 +50,7 @@ function isLspPosition(value: unknown): value is ILspPosition {
   return typeof value.line === "number" && typeof value.character === "number";
 }
 
-function isLspRange(value: unknown): value is ILspRange {
+function isLspRange(value: unknown): value is LspRange {
   if (!isRecord(value)) {
     return false;
   }
@@ -58,7 +58,7 @@ function isLspRange(value: unknown): value is ILspRange {
   return isLspPosition(value.start) && isLspPosition(value.end);
 }
 
-function isLspTextEdit(value: unknown): value is ILspTextEdit {
+function isLspTextEdit(value: unknown): value is LspTextEdit {
   if (!isRecord(value)) {
     return false;
   }
@@ -66,7 +66,7 @@ function isLspTextEdit(value: unknown): value is ILspTextEdit {
   return typeof value.newText === "string" && isLspRange(value.range);
 }
 
-function isLspWorkspaceEdit(value: unknown): value is ILspWorkspaceEdit {
+function isLspWorkspaceEdit(value: unknown): value is LspWorkspaceEdit {
   if (!isRecord(value) || !isRecord(value.changes)) {
     return false;
   }
@@ -86,7 +86,7 @@ function isLspWorkspaceEdit(value: unknown): value is ILspWorkspaceEdit {
   return true;
 }
 
-function compareTextEdit(left: ITextEdit, right: ITextEdit): number {
+function compareTextEdit(left: TextEdit, right: TextEdit): number {
   if (left.filePath !== right.filePath) {
     return left.filePath.localeCompare(right.filePath);
   }
@@ -102,7 +102,7 @@ function compareTextEdit(left: ITextEdit, right: ITextEdit): number {
   return left.newText.localeCompare(right.newText);
 }
 
-function readTextEdit(uri: string, textEdit: ILspTextEdit): ITextEdit {
+function readTextEdit(uri: string, textEdit: LspTextEdit): TextEdit {
   return {
     end: textEdit.range.end,
     filePath: fileURLToPath(uri),
@@ -111,8 +111,8 @@ function readTextEdit(uri: string, textEdit: ILspTextEdit): ITextEdit {
   };
 }
 
-function readTextEdits(workspaceEdit: ILspWorkspaceEdit): readonly ITextEdit[] {
-  const textEdits: ITextEdit[] = [];
+function readTextEdits(workspaceEdit: LspWorkspaceEdit): readonly TextEdit[] {
+  const textEdits: TextEdit[] = [];
 
   for (const [uri, edits] of Object.entries(workspaceEdit.changes)) {
     for (const textEdit of edits) {
@@ -132,9 +132,9 @@ function readFailureReason(error: unknown): string {
 }
 
 async function readClient(
-  clientCache: IClientCache,
-  context: ISemanticFixBackendContext,
-  options: Pick<IApplySemanticFixesOptions, "tsgoExecutablePath">,
+  clientCache: ClientCache,
+  context: SemanticFixBackendContext,
+  options: Pick<ApplySemanticFixesOptions, "tsgoExecutablePath">,
 ): Promise<TsgoLspClient> {
   const cachedClient = clientCache.get(context.targetDirectoryPath);
   if (cachedClient) {
@@ -150,19 +150,19 @@ async function readClient(
   return client;
 }
 
-function readRenameSymbolDescription(operation: ISymbolRenameOperation): string {
+function readRenameSymbolDescription(operation: SymbolRenameOperation): string {
   return `Rename ${operation.symbolName} to ${operation.newName}`;
 }
 
-function readMoveFileDescription(operation: IMoveFileOperation): string {
+function readMoveFileDescription(operation: MoveFileOperation): string {
   return `Move ${operation.filePath} to ${operation.newFilePath}`;
 }
 
 function readPlan(
-  operation: ISemanticFixOperation,
-  textEdits: readonly ITextEdit[],
-  fileMoves: readonly IFileMove[] = [],
-): ISemanticFixPlan {
+  operation: SemanticFixOperation,
+  textEdits: readonly TextEdit[],
+  fileMoves: readonly FileMove[] = [],
+): SemanticFixPlan {
   return {
     description:
       operation.kind === "rename-symbol" ? readRenameSymbolDescription(operation) : readMoveFileDescription(operation),
@@ -174,12 +174,12 @@ function readPlan(
 }
 
 export function createTsgoLspSemanticFixBackend(
-  options: Pick<IApplySemanticFixesOptions, "tsgoExecutablePath">,
-): ISemanticFixBackend {
-  const clientCache: IClientCache = new Map();
+  options: Pick<ApplySemanticFixesOptions, "tsgoExecutablePath">,
+): SemanticFixBackend {
+  const clientCache: ClientCache = new Map();
 
   return {
-    async createPlan(operation, context): Promise<ISemanticFixPlanResult> {
+    async createPlan(operation, context): Promise<SemanticFixPlanResult> {
       switch (operation.kind) {
         case "rename-symbol": {
           const client = await readClient(clientCache, context, options);

package/src/semantic-fixes/providers/createInterfaceNamingConventionSemanticFixProvider.ts

@@ -1,71 +1,15 @@
-import { readFileSync } from "node:fs";
-import { isAbsolute, resolve } from "node:path";
 import ts from "typescript";
 import type {
-  IOxlintDiagnostic,
-  ISemanticFixOperation,
-  ISemanticFixProvider,
-  ISemanticFixProviderContext,
+  OxlintDiagnostic,
+  SemanticFixOperation,
+  SemanticFixProvider,
+  SemanticFixProviderContext,
 } from "../types.ts";
-
-function readAbsoluteDiagnosticFilePath(diagnostic: IOxlintDiagnostic, context: ISemanticFixProviderContext): string {
-  if (isAbsolute(diagnostic.filename)) {
-    return diagnostic.filename;
-  }
-
-  return resolve(context.targetDirectoryPath, diagnostic.filename);
-}
-
-function readInterfaceDeclarationAtOffset(node: ts.Node, offset: number): ts.InterfaceDeclaration | null {
-  if (ts.isInterfaceDeclaration(node)) {
-    const start = node.name.getStart();
-    const end = node.name.getEnd();
-    if (offset >= start && offset <= end) {
-      return node;
-    }
-  }
-
-  let matchingDeclaration: ts.InterfaceDeclaration | null = null;
-
-  ts.forEachChild(node, (childNode) => {
-    if (matchingDeclaration) {
-      return;
-    }
-
-    matchingDeclaration = readInterfaceDeclarationAtOffset(childNode, offset);
-  });
-
-  return matchingDeclaration;
-}
-
-function readOffsetFromLineAndColumn(sourceFile: ts.SourceFile, line: number, column: number): number | null {
-  if (line < 1 || column < 1) {
-    return null;
-  }
-
-  try {
-    return ts.getPositionOfLineAndCharacter(sourceFile, line - 1, column - 1);
-  } catch {
-    return null;
-  }
-}
-
-function readInterfaceDeclarationFromLabel(
-  sourceFile: ts.SourceFile,
-  label: IOxlintDiagnostic["labels"][number],
-): ts.InterfaceDeclaration | null {
-  const declarationAtReportedOffset = readInterfaceDeclarationAtOffset(sourceFile, label.span.offset);
-  if (declarationAtReportedOffset) {
-    return declarationAtReportedOffset;
-  }
-
-  const offsetFromLineAndColumn = readOffsetFromLineAndColumn(sourceFile, label.span.line, label.span.column);
-  if (offsetFromLineAndColumn === null || offsetFromLineAndColumn === label.span.offset) {
-    return null;
-  }
-
-  return readInterfaceDeclarationAtOffset(sourceFile, offsetFromLineAndColumn);
-}
+import {
+  readDiagnosticSourceFile,
+  readNamedDeclarationFromDiagnosticLabel,
+  readRenameSymbolOperation,
+} from "./helpers.ts";
 
 function readNormalizedInterfaceName(interfaceName: string): string | null {
   const rawBaseName = /^[Ii]/.test(interfaceName) ? interfaceName.slice(1) : interfaceName;
@@ -83,19 +27,14 @@ function readNormalizedInterfaceName(interfaceName: string): string | null {
   return normalizedInterfaceName;
 }
 
-function readOperation(
-  diagnostic: IOxlintDiagnostic,
-  context: ISemanticFixProviderContext,
-): ISemanticFixOperation | null {
+function readOperation(diagnostic: OxlintDiagnostic, context: SemanticFixProviderContext): SemanticFixOperation | null {
   const label = diagnostic.labels[0];
   if (!label) {
     return null;
   }
 
-  const filePath = readAbsoluteDiagnosticFilePath(diagnostic, context);
-  const content = readFileSync(filePath, "utf8");
-  const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-  const interfaceDeclaration = readInterfaceDeclarationFromLabel(sourceFile, label);
+  const sourceFile = readDiagnosticSourceFile(diagnostic, context);
+  const interfaceDeclaration = readNamedDeclarationFromDiagnosticLabel(sourceFile, label, ts.isInterfaceDeclaration);
   if (!interfaceDeclaration) {
     return null;
   }
@@ -106,25 +45,12 @@ function readOperation(
     return null;
   }
 
-  const start = ts.getLineAndCharacterOfPosition(sourceFile, interfaceDeclaration.name.getStart());
-
-  return {
-    filePath,
-    id: `${diagnostic.code}:${filePath}:${start.line}:${start.character}:${newName}`,
-    kind: "rename-symbol",
-    newName,
-    position: {
-      character: start.character,
-      line: start.line,
-    },
-    ruleCode: diagnostic.code,
-    symbolName,
-  };
+  return readRenameSymbolOperation(diagnostic, sourceFile, interfaceDeclaration.name, newName);
 }
 
-export function createInterfaceNamingConventionSemanticFixProvider(): ISemanticFixProvider {
+export function createInterfaceNamingConventionSemanticFixProvider(): SemanticFixProvider {
   return {
-    createOperation(diagnostic, context): ISemanticFixOperation | null {
+    createOperation(diagnostic, context): SemanticFixOperation | null {
       return readOperation(diagnostic, context);
     },
     ruleCode: "@alexgorbatchev/interface-naming-convention",