@alexgorbatchev/typescript-ai-policy 0.1.0

package/src/semantic-fixes/applySemanticFixes.ts

@@ -0,0 +1,239 @@
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { applyFileChanges } from "./applyFileChanges.ts";
+import { createTsgoLspSemanticFixBackend } from "./backends/tsgo-lsp/createTsgoLspSemanticFixBackend.ts";
+import { createInterfaceNamingConventionSemanticFixProvider } from "./providers/createInterfaceNamingConventionSemanticFixProvider.ts";
+import { createTestFileLocationConventionSemanticFixProvider } from "./providers/createTestFileLocationConventionSemanticFixProvider.ts";
+import { runOxlintJson } from "./runOxlintJson.ts";
+import type {
+  IApplySemanticFixesOptions,
+  IApplySemanticFixesProgressEvent,
+  IApplySemanticFixesResult,
+  IOxlintDiagnostic,
+  ISemanticFixOperation,
+  ISemanticFixPlan,
+  ISkippedDiagnostic,
+} from "./types.ts";
+
+function readAbsoluteDiagnosticFilePath(targetDirectoryPath: string, diagnostic: IOxlintDiagnostic): string {
+  if (isAbsolute(diagnostic.filename)) {
+    return diagnostic.filename;
+  }
+
+  return resolve(targetDirectoryPath, diagnostic.filename);
+}
+
+function readSkippedDiagnostic(
+  targetDirectoryPath: string,
+  diagnostic: IOxlintDiagnostic,
+  reason: string,
+): ISkippedDiagnostic {
+  return {
+    filePath: readAbsoluteDiagnosticFilePath(targetDirectoryPath, diagnostic),
+    reason,
+    ruleCode: diagnostic.code,
+  };
+}
+
+function readPlanSignature(plan: ISemanticFixPlan): string {
+  return JSON.stringify({
+    fileMoves: plan.fileMoves,
+    textEdits: plan.textEdits,
+  });
+}
+
+function readChangedFilePaths(plans: readonly ISemanticFixPlan[]): readonly string[] {
+  const changedFilePathSet = new Set<string>();
+  const movedFilePathMap = new Map<string, string>();
+
+  for (const plan of plans) {
+    for (const fileMove of plan.fileMoves) {
+      movedFilePathMap.set(fileMove.sourceFilePath, fileMove.destinationFilePath);
+      changedFilePathSet.add(fileMove.destinationFilePath);
+    }
+  }
+
+  for (const plan of plans) {
+    for (const textEdit of plan.textEdits) {
+      changedFilePathSet.add(movedFilePathMap.get(textEdit.filePath) ?? textEdit.filePath);
+    }
+  }
+
+  return [...changedFilePathSet].sort((left, right) => left.localeCompare(right));
+}
+
+function readOperationDescription(operation: ISemanticFixOperation): string {
+  switch (operation.kind) {
+    case "rename-symbol": {
+      return `Rename ${operation.symbolName} to ${operation.newName}`;
+    }
+    case "move-file": {
+      return `Move ${relative(dirname(operation.filePath), operation.filePath)} to ${relative(dirname(operation.filePath), operation.newFilePath)}`;
+    }
+  }
+}
+
+function readOperationEmptyPlanReason(operation: ISemanticFixOperation): string {
+  switch (operation.kind) {
+    case "rename-symbol": {
+      return `No text edits were produced for ${operation.symbolName}.`;
+    }
+    case "move-file": {
+      return `No file changes were produced for ${relative(dirname(operation.filePath), operation.filePath)}.`;
+    }
+  }
+}
+
+function readUniqueOperations(operations: readonly ISemanticFixOperation[]): readonly ISemanticFixOperation[] {
+  const operationMap = new Map<string, ISemanticFixOperation>();
+
+  for (const operation of operations) {
+    operationMap.set(operation.id, operation);
+  }
+
+  return [...operationMap.values()];
+}
+
+function readUniquePlans(plans: readonly ISemanticFixPlan[]): readonly ISemanticFixPlan[] {
+  const planMap = new Map<string, ISemanticFixPlan>();
+
+  for (const plan of plans) {
+    planMap.set(readPlanSignature(plan), plan);
+  }
+
+  return [...planMap.values()];
+}
+
+export async function applySemanticFixes(options: IApplySemanticFixesOptions): Promise<IApplySemanticFixesResult> {
+  const reportProgress = (event: IApplySemanticFixesProgressEvent): void => {
+    options.onProgress?.(event);
+  };
+  const semanticFixProviders = new Map(
+    [createInterfaceNamingConventionSemanticFixProvider(), createTestFileLocationConventionSemanticFixProvider()].map(
+      (semanticFixProvider) => [semanticFixProvider.ruleCode, semanticFixProvider],
+    ),
+  );
+  const semanticFixBackend = createTsgoLspSemanticFixBackend({
+    tsgoExecutablePath: options.tsgoExecutablePath,
+  });
+
+  try {
+    reportProgress({
+      kind: "running-oxlint",
+      targetDirectoryPath: options.targetDirectoryPath,
+    });
+
+    const diagnostics = await runOxlintJson({
+      oxlintConfigPath: options.oxlintConfigPath,
+      oxlintExecutablePath: options.oxlintExecutablePath,
+      targetDirectoryPath: options.targetDirectoryPath,
+    });
+
+    reportProgress({
+      diagnosticCount: diagnostics.length,
+      kind: "collected-diagnostics",
+    });
+
+    const skippedDiagnostics: ISkippedDiagnostic[] = [];
+    const operations: ISemanticFixOperation[] = [];
+
+    for (const diagnostic of diagnostics) {
+      const semanticFixProviderForDiagnostic = semanticFixProviders.get(diagnostic.code);
+      if (!semanticFixProviderForDiagnostic) {
+        continue;
+      }
+
+      const operation = semanticFixProviderForDiagnostic.createOperation(diagnostic, {
+        targetDirectoryPath: options.targetDirectoryPath,
+      });
+      if (!operation) {
+        skippedDiagnostics.push(
+          readSkippedDiagnostic(
+            options.targetDirectoryPath,
+            diagnostic,
+            "No safe semantic fix is available for this diagnostic.",
+          ),
+        );
+        continue;
+      }
+
+      operations.push(operation);
+    }
+
+    const uniqueOperations = readUniqueOperations(operations);
+    const plans: ISemanticFixPlan[] = [];
+
+    reportProgress({
+      kind: "planning-start",
+      operationCount: uniqueOperations.length,
+    });
+
+    for (const [operationIndex, operation] of uniqueOperations.entries()) {
+      reportProgress({
+        description: readOperationDescription(operation),
+        kind: "planning-operation",
+        operationCount: uniqueOperations.length,
+        operationId: operation.id,
+        operationIndex: operationIndex + 1,
+      });
+
+      const planResult = await semanticFixBackend.createPlan(operation, {
+        targetDirectoryPath: options.targetDirectoryPath,
+      });
+
+      if (planResult.kind === "skip") {
+        skippedDiagnostics.push({
+          filePath: operation.filePath,
+          reason: planResult.reason,
+          ruleCode: operation.ruleCode,
+        });
+        continue;
+      }
+
+      if (planResult.plan.textEdits.length === 0 && planResult.plan.fileMoves.length === 0) {
+        skippedDiagnostics.push({
+          filePath: operation.filePath,
+          reason: readOperationEmptyPlanReason(operation),
+          ruleCode: operation.ruleCode,
+        });
+        continue;
+      }
+
+      plans.push(planResult.plan);
+    }
+
+    const uniquePlans = readUniquePlans(plans);
+    const allTextEdits = uniquePlans.flatMap((plan) => plan.textEdits);
+    const plannedChangedFilePaths = readChangedFilePaths(uniquePlans);
+
+    const fileMoves = uniquePlans.flatMap((plan) => plan.fileMoves);
+
+    reportProgress({
+      dryRun: options.dryRun ?? false,
+      fileCount: plannedChangedFilePaths.length,
+      kind: "applying-file-changes",
+      moveCount: fileMoves.length,
+      textEditCount: allTextEdits.length,
+    });
+
+    const changedFilePaths = options.dryRun ? plannedChangedFilePaths : applyFileChanges(allTextEdits, fileMoves);
+    const result = {
+      appliedFileCount: options.dryRun ? 0 : changedFilePaths.length,
+      backendName: semanticFixBackend.name,
+      changedFilePaths,
+      plannedFixCount: uniquePlans.length,
+      skippedDiagnostics,
+    };
+
+    reportProgress({
+      appliedFileCount: result.appliedFileCount,
+      changedFileCount: result.changedFilePaths.length,
+      kind: "complete",
+      plannedFixCount: result.plannedFixCount,
+      skippedDiagnosticCount: result.skippedDiagnostics.length,
+    });
+
+    return result;
+  } finally {
+    await semanticFixBackend.dispose();
+  }
+}

package/src/semantic-fixes/applyTextEdits.ts

@@ -0,0 +1,164 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import ts from "typescript";
+import type { ITextEdit } from "./types.ts";
+
+type IOffsetTextEdit = {
+  endOffset: number;
+  newText: string;
+  startOffset: number;
+};
+
+type IFileEditEntry = {
+  filePath: string;
+  textEdits: readonly ITextEdit[];
+};
+
+function readFileEditEntries(textEdits: readonly ITextEdit[]): readonly IFileEditEntry[] {
+  const textEditsByFilePath = new Map<string, ITextEdit[]>();
+
+  for (const textEdit of textEdits) {
+    const existingTextEdits = textEditsByFilePath.get(textEdit.filePath);
+    if (existingTextEdits) {
+      existingTextEdits.push(textEdit);
+      continue;
+    }
+
+    textEditsByFilePath.set(textEdit.filePath, [textEdit]);
+  }
+
+  return [...textEditsByFilePath.entries()].map(([filePath, groupedTextEdits]) => ({
+    filePath,
+    textEdits: groupedTextEdits,
+  }));
+}
+
+function compareOffsetTextEditsAscending(left: IOffsetTextEdit, right: IOffsetTextEdit): number {
+  if (left.startOffset !== right.startOffset) {
+    return left.startOffset - right.startOffset;
+  }
+
+  if (left.endOffset !== right.endOffset) {
+    return left.endOffset - right.endOffset;
+  }
+
+  return left.newText.localeCompare(right.newText);
+}
+
+function compareOffsetTextEditsDescending(left: IOffsetTextEdit, right: IOffsetTextEdit): number {
+  return compareOffsetTextEditsAscending(right, left);
+}
+
+function readOffset(positionContent: string, line: number, character: number): number {
+  const sourceFile = ts.createSourceFile("file.ts", positionContent, ts.ScriptTarget.Latest, true);
+  return ts.getPositionOfLineAndCharacter(sourceFile, line, character);
+}
+
+function readOffsetTextEdit(content: string, textEdit: ITextEdit): IOffsetTextEdit {
+  return {
+    endOffset: readOffset(content, textEdit.end.line, textEdit.end.character),
+    newText: textEdit.newText,
+    startOffset: readOffset(content, textEdit.start.line, textEdit.start.character),
+  };
+}
+
+function haveSameRange(left: IOffsetTextEdit, right: IOffsetTextEdit): boolean {
+  return left.startOffset === right.startOffset && left.endOffset === right.endOffset;
+}
+
+function isInsertion(edit: IOffsetTextEdit): boolean {
+  return edit.startOffset === edit.endOffset;
+}
+
+function haveSameInsertionPoint(left: IOffsetTextEdit, right: IOffsetTextEdit): boolean {
+  return isInsertion(left) && isInsertion(right) && left.startOffset === right.startOffset;
+}
+
+function rangesOverlap(left: IOffsetTextEdit, right: IOffsetTextEdit): boolean {
+  return left.startOffset < right.endOffset && right.startOffset < left.endOffset;
+}
+
+function containsRange(container: IOffsetTextEdit, candidate: IOffsetTextEdit): boolean {
+  return container.startOffset <= candidate.startOffset && container.endOffset >= candidate.endOffset;
+}
+
+function readNormalizedOffsetTextEdits(
+  filePath: string,
+  offsetTextEdits: readonly IOffsetTextEdit[],
+): readonly IOffsetTextEdit[] {
+  const normalizedOffsetTextEdits: IOffsetTextEdit[] = [];
+
+  for (const offsetTextEdit of [...offsetTextEdits].sort(compareOffsetTextEditsAscending)) {
+    const previousOffsetTextEdit = normalizedOffsetTextEdits.at(-1);
+    if (!previousOffsetTextEdit) {
+      normalizedOffsetTextEdits.push(offsetTextEdit);
+      continue;
+    }
+
+    const sharesRange = haveSameRange(previousOffsetTextEdit, offsetTextEdit);
+    const sharesInsertionPoint = haveSameInsertionPoint(previousOffsetTextEdit, offsetTextEdit);
+    const overlapsPreviousRange = rangesOverlap(previousOffsetTextEdit, offsetTextEdit);
+    const hasSameReplacement = previousOffsetTextEdit.newText === offsetTextEdit.newText;
+
+    if (!sharesRange && !sharesInsertionPoint && !overlapsPreviousRange) {
+      normalizedOffsetTextEdits.push(offsetTextEdit);
+      continue;
+    }
+
+    if (hasSameReplacement && (sharesRange || sharesInsertionPoint)) {
+      continue;
+    }
+
+    if (hasSameReplacement && containsRange(offsetTextEdit, previousOffsetTextEdit)) {
+      continue;
+    }
+
+    if (hasSameReplacement && containsRange(previousOffsetTextEdit, offsetTextEdit)) {
+      normalizedOffsetTextEdits[normalizedOffsetTextEdits.length - 1] = offsetTextEdit;
+      continue;
+    }
+
+    throw new Error(`Overlapping semantic fix edits detected in ${filePath}`);
+  }
+
+  return normalizedOffsetTextEdits;
+}
+
+export function readUpdatedContent(filePath: string, content: string, textEdits: readonly ITextEdit[]): string {
+  const offsetTextEdits = [
+    ...readNormalizedOffsetTextEdits(
+      filePath,
+      textEdits.map((textEdit) => readOffsetTextEdit(content, textEdit)),
+    ),
+  ].sort(compareOffsetTextEditsDescending);
+
+  let updatedContent = content;
+
+  for (const offsetTextEdit of offsetTextEdits) {
+    updatedContent =
+      updatedContent.slice(0, offsetTextEdit.startOffset) +
+      offsetTextEdit.newText +
+      updatedContent.slice(offsetTextEdit.endOffset);
+  }
+
+  return updatedContent;
+}
+
+function applyFileTextEdits(filePath: string, textEdits: readonly ITextEdit[]): void {
+  const content = readFileSync(filePath, "utf8");
+  const updatedContent = readUpdatedContent(filePath, content, textEdits);
+
+  if (updatedContent !== content) {
+    writeFileSync(filePath, updatedContent, "utf8");
+  }
+}
+
+export function applyTextEdits(textEdits: readonly ITextEdit[]): readonly string[] {
+  const changedFilePaths: string[] = [];
+
+  for (const fileEditEntry of readFileEditEntries(textEdits)) {
+    applyFileTextEdits(fileEditEntry.filePath, fileEditEntry.textEdits);
+    changedFilePaths.push(fileEditEntry.filePath);
+  }
+
+  return changedFilePaths.sort((left, right) => left.localeCompare(right));
+}