@alexgorbatchev/typescript-ai-policy 1.0.2 → 1.0.3

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

@@ -0,0 +1,117 @@
+import { readFileSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import ts from "typescript";
+import type { OxlintDiagnostic, SemanticFixProviderContext, SymbolRenameOperation } from "../types.ts";
+
+type NamedDeclarationWithIdentifier = ts.Node & {
+  name: ts.Identifier;
+};
+
+type NamedDeclarationMatcher<TDeclaration extends NamedDeclarationWithIdentifier> = (
+  node: ts.Node,
+) => node is TDeclaration;
+
+export function readAbsoluteDiagnosticFilePath(
+  diagnostic: OxlintDiagnostic,
+  context: SemanticFixProviderContext,
+): string {
+  if (isAbsolute(diagnostic.filename)) {
+    return diagnostic.filename;
+  }
+
+  return resolve(context.targetDirectoryPath, diagnostic.filename);
+}
+
+export function readDiagnosticSourceFile(
+  diagnostic: OxlintDiagnostic,
+  context: SemanticFixProviderContext,
+): ts.SourceFile {
+  const filePath = readAbsoluteDiagnosticFilePath(diagnostic, context);
+  const content = readFileSync(filePath, "utf8");
+
+  return ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+}
+
+export 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;
+  }
+}
+
+export function readNamedDeclarationAtOffset<TDeclaration extends NamedDeclarationWithIdentifier>(
+  node: ts.Node,
+  offset: number,
+  isMatchingDeclaration: NamedDeclarationMatcher<TDeclaration>,
+): TDeclaration | null {
+  if (isMatchingDeclaration(node)) {
+    const declarationNameStart = node.name.getStart();
+    const declarationNameEnd = node.name.getEnd();
+    if (offset >= declarationNameStart && offset <= declarationNameEnd) {
+      return node;
+    }
+  }
+
+  let matchingDeclaration: TDeclaration | null = null;
+
+  ts.forEachChild(node, (childNode) => {
+    if (matchingDeclaration) {
+      return;
+    }
+
+    matchingDeclaration = readNamedDeclarationAtOffset(childNode, offset, isMatchingDeclaration);
+  });
+
+  return matchingDeclaration;
+}
+
+export function readNamedDeclarationFromDiagnosticLabel<TDeclaration extends NamedDeclarationWithIdentifier>(
+  sourceFile: ts.SourceFile,
+  label: OxlintDiagnostic["labels"][number],
+  isMatchingDeclaration: NamedDeclarationMatcher<TDeclaration>,
+): TDeclaration | null {
+  const declarationAtReportedOffset = readNamedDeclarationAtOffset(
+    sourceFile,
+    label.span.offset,
+    isMatchingDeclaration,
+  );
+  if (declarationAtReportedOffset) {
+    return declarationAtReportedOffset;
+  }
+
+  const offsetFromLineAndColumn = readOffsetFromLineAndColumn(sourceFile, label.span.line, label.span.column);
+  if (offsetFromLineAndColumn === null || offsetFromLineAndColumn === label.span.offset) {
+    return null;
+  }
+
+  return readNamedDeclarationAtOffset(sourceFile, offsetFromLineAndColumn, isMatchingDeclaration);
+}
+
+export function readRenameSymbolOperation(
+  diagnostic: OxlintDiagnostic,
+  sourceFile: ts.SourceFile,
+  declarationName: ts.Identifier,
+  newName: string,
+): SymbolRenameOperation {
+  const filePath = sourceFile.fileName;
+  const start = ts.getLineAndCharacterOfPosition(sourceFile, declarationName.getStart());
+  const symbolName = declarationName.text;
+
+  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,
+  };
+}

package/src/semantic-fixes/readMovedFileTextEdits.ts

@@ -1,7 +1,7 @@
 import { dirname, relative, resolve } from "node:path";
 import { readFileSync } from "node:fs";
 import ts from "typescript";
-import type { ITextEdit } from "./types.ts";
+import type { TextEdit } from "./types.ts";
 
 function isRelativeModuleSpecifier(moduleSpecifier: string): boolean {
   return (
@@ -21,7 +21,7 @@ function readRelativeModuleSpecifier(fromDirectoryPath: string, targetPath: stri
   return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
 }
 
-type IModuleSpecifierEntry = {
+type ModuleSpecifierEntry = {
   moduleSpecifier: string;
   node: ts.StringLiteralLike;
 };
@@ -34,7 +34,7 @@ function readImportTypeArgumentLiteral(node: ts.ImportTypeNode): ts.StringLitera
   return ts.isStringLiteralLike(node.argument.literal) ? node.argument.literal : null;
 }
 
-function readModuleSpecifierEntry(node: ts.Node): IModuleSpecifierEntry | null {
+function readModuleSpecifierEntry(node: ts.Node): ModuleSpecifierEntry | null {
   if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
     return node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)
       ? {
@@ -88,8 +88,8 @@ function readModuleSpecifierEntry(node: ts.Node): IModuleSpecifierEntry | null {
   return null;
 }
 
-function readModuleSpecifierEntries(sourceFile: ts.SourceFile): readonly IModuleSpecifierEntry[] {
-  const moduleSpecifierEntries: IModuleSpecifierEntry[] = [];
+function readModuleSpecifierEntries(sourceFile: ts.SourceFile): readonly ModuleSpecifierEntry[] {
+  const moduleSpecifierEntries: ModuleSpecifierEntry[] = [];
 
   function visitNode(node: ts.Node): void {
     const moduleSpecifierEntry = readModuleSpecifierEntry(node);
@@ -105,12 +105,12 @@ function readModuleSpecifierEntries(sourceFile: ts.SourceFile): readonly IModule
   return moduleSpecifierEntries;
 }
 
-export function readMovedFileTextEdits(sourceFilePath: string, destinationFilePath: string): readonly ITextEdit[] {
+export function readMovedFileTextEdits(sourceFilePath: string, destinationFilePath: string): readonly TextEdit[] {
   const content = readFileSync(sourceFilePath, "utf8");
   const sourceFile = ts.createSourceFile(sourceFilePath, content, ts.ScriptTarget.Latest, true);
   const sourceDirectoryPath = dirname(sourceFilePath);
   const destinationDirectoryPath = dirname(destinationFilePath);
-  const textEdits: ITextEdit[] = [];
+  const textEdits: TextEdit[] = [];
 
   for (const moduleSpecifierEntry of readModuleSpecifierEntries(sourceFile)) {
     if (!isRelativeModuleSpecifier(moduleSpecifierEntry.moduleSpecifier)) {

package/src/semantic-fixes/readSemanticFixRuntimePaths.ts

@@ -2,7 +2,7 @@ import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-export type ISemanticFixRuntimePaths = {
+export type SemanticFixRuntimePaths = {
   oxlintConfigPath: string;
   oxlintExecutablePath: string;
   tsgoExecutablePath: string;
@@ -20,7 +20,7 @@ function readInstalledPackageRootPath(packageName: string, resolutionFailureMess
   }
 }
 
-export function readSemanticFixRuntimePaths(): ISemanticFixRuntimePaths {
+export function readSemanticFixRuntimePaths(): SemanticFixRuntimePaths {
   const oxlintPackageRootPath = readInstalledPackageRootPath(
     "oxlint",
     'Missing peer dependency "oxlint". Install oxlint in the consuming project so the semantic-fix CLI can run repository policy checks.',

package/src/semantic-fixes/runApplySemanticFixes.ts

@@ -4,9 +4,9 @@ import { existsSync, statSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 import { applySemanticFixes } from "./applySemanticFixes.ts";
 import { readSemanticFixRuntimePaths } from "./readSemanticFixRuntimePaths.ts";
-import type { IApplySemanticFixesProgressEvent, ISkippedDiagnostic } from "./types.ts";
+import type { ApplySemanticFixesProgressEvent, SkippedDiagnostic } from "./types.ts";
 
-type ICliOptions = {
+type CliOptions = {
   dryRun: boolean;
   targetDirectoryPath: string;
 };
@@ -26,7 +26,7 @@ function readUsageText(): string {
   ].join("\n");
 }
 
-function readCliOptions(argv: readonly string[]): ICliOptions {
+function readCliOptions(argv: readonly string[]): CliOptions {
   const remainingArguments = argv.slice(2);
   const targetDirectoryArgument = remainingArguments.find((argument) => !argument.startsWith("-"));
   if (!targetDirectoryArgument) {
@@ -54,11 +54,11 @@ function readDisplayPath(targetDirectoryPath: string, filePath: string): string
   return relativeFilePath.length > 0 ? relativeFilePath : ".";
 }
 
-function formatSkippedDiagnostic(targetDirectoryPath: string, skippedDiagnostic: ISkippedDiagnostic): string {
+function formatSkippedDiagnostic(targetDirectoryPath: string, skippedDiagnostic: SkippedDiagnostic): string {
   return `- [${skippedDiagnostic.ruleCode}] ${readDisplayPath(targetDirectoryPath, skippedDiagnostic.filePath)}: ${skippedDiagnostic.reason}`;
 }
 
-function formatProgressEvent(event: IApplySemanticFixesProgressEvent): string {
+function formatProgressEvent(event: ApplySemanticFixesProgressEvent): string {
   switch (event.kind) {
     case "running-oxlint": {
       return "running oxlint...";

package/src/semantic-fixes/runOxlintJson.ts

@@ -3,20 +3,20 @@ import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { spawn } from "node:child_process";
-import type { IOxlintDiagnostic } from "./types.ts";
+import type { OxlintDiagnostic } from "./types.ts";
 
-type IRunOxlintJsonOptions = {
+type RunOxlintJsonOptions = {
   oxlintConfigPath: string;
   oxlintExecutablePath: string;
   targetDirectoryPath: string;
 };
 
-type IOxlintProcessCompletion = {
+type OxlintProcessCompletion = {
   exitCode: number | null;
   signal: NodeJS.Signals | null;
 };
 
-type IOxlintProcessResult = IOxlintProcessCompletion & {
+type OxlintProcessResult = OxlintProcessCompletion & {
   stderr: string;
   stdout: string;
 };
@@ -25,7 +25,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null;
 }
 
-function isOxlintDiagnostic(value: unknown): value is IOxlintDiagnostic {
+function isOxlintDiagnostic(value: unknown): value is OxlintDiagnostic {
   if (!isRecord(value)) {
     return false;
   }
@@ -49,7 +49,7 @@ function readNormalizedRuleCode(ruleCode: string): string {
   return `${pluginName}/${localRuleName}`;
 }
 
-function readDiagnostics(report: unknown): readonly IOxlintDiagnostic[] {
+function readDiagnostics(report: unknown): readonly OxlintDiagnostic[] {
   if (!isRecord(report) || !Array.isArray(report.diagnostics)) {
     throw new Error(`Unexpected Oxlint JSON output: ${JSON.stringify(report)}`);
   }
@@ -65,7 +65,7 @@ function readDiagnostics(report: unknown): readonly IOxlintDiagnostic[] {
   }));
 }
 
-async function runOxlintProcess(options: IRunOxlintJsonOptions): Promise<IOxlintProcessResult> {
+async function runOxlintProcess(options: RunOxlintJsonOptions): Promise<OxlintProcessResult> {
   const tempDirectoryPath = await mkdtemp(join(tmpdir(), "semantic-fixes-oxlint-"));
   const stdoutPath = join(tempDirectoryPath, "oxlint-report.json");
   const stdoutFileDescriptor = openSync(stdoutPath, "w");
@@ -96,7 +96,7 @@ async function runOxlintProcess(options: IRunOxlintJsonOptions): Promise<IOxlint
       stderrChunks.push(chunk.toString("utf8"));
     });
 
-    const processCompletion = await new Promise<IOxlintProcessCompletion>((resolve, reject) => {
+    const processCompletion = await new Promise<OxlintProcessCompletion>((resolve, reject) => {
       childProcess.once("error", (error: Error) => {
         reject(error);
       });
@@ -118,7 +118,7 @@ async function runOxlintProcess(options: IRunOxlintJsonOptions): Promise<IOxlint
   }
 }
 
-export async function runOxlintJson(options: IRunOxlintJsonOptions): Promise<readonly IOxlintDiagnostic[]> {
+export async function runOxlintJson(options: RunOxlintJsonOptions): Promise<readonly OxlintDiagnostic[]> {
   const runResult = await runOxlintProcess(options);
   const stdout = runResult.stdout.trim();
   if (stdout.length === 0) {

package/src/semantic-fixes/types.ts

@@ -1,50 +1,50 @@
-export type IOxlintSpan = {
+export type OxlintSpan = {
   column: number;
   length: number;
   line: number;
   offset: number;
 };
 
-export type IOxlintLabel = {
+export type OxlintLabel = {
   label?: string;
-  span: IOxlintSpan;
+  span: OxlintSpan;
 };
 
-export type IOxlintDiagnostic = {
+export type OxlintDiagnostic = {
   code: string;
   filename: string;
-  labels: readonly IOxlintLabel[];
+  labels: readonly OxlintLabel[];
   message: string;
   severity: string;
 };
 
-export type IOxlintJsonReport = {
-  diagnostics: readonly IOxlintDiagnostic[];
+export type OxlintJsonReport = {
+  diagnostics: readonly OxlintDiagnostic[];
 };
 
-export type ILineAndCharacter = {
+export type LineAndCharacter = {
   character: number;
   line: number;
 };
 
-export type ITextEdit = {
-  end: ILineAndCharacter;
+export type TextEdit = {
+  end: LineAndCharacter;
   filePath: string;
   newText: string;
-  start: ILineAndCharacter;
+  start: LineAndCharacter;
 };
 
-export type ISymbolRenameOperation = {
+export type SymbolRenameOperation = {
   filePath: string;
   id: string;
   kind: "rename-symbol";
   newName: string;
-  position: ILineAndCharacter;
+  position: LineAndCharacter;
   ruleCode: string;
   symbolName: string;
 };
 
-export type IMoveFileOperation = {
+export type MoveFileOperation = {
   filePath: string;
   id: string;
   kind: "move-file";
@@ -52,59 +52,53 @@ export type IMoveFileOperation = {
   ruleCode: string;
 };
 
-export type ISemanticFixOperation = ISymbolRenameOperation | IMoveFileOperation;
+export type SemanticFixOperation = SymbolRenameOperation | MoveFileOperation;
 
-export type IFileMove = {
+export type FileMove = {
   destinationFilePath: string;
   sourceFilePath: string;
 };
 
-export type ISemanticFixPlan = {
+export type SemanticFixPlan = {
   description: string;
-  fileMoves: readonly IFileMove[];
+  fileMoves: readonly FileMove[];
   operationId: string;
   ruleCode: string;
-  textEdits: readonly ITextEdit[];
+  textEdits: readonly TextEdit[];
 };
 
-export type ISemanticFixPlanSuccess = {
+export type SemanticFixPlanSuccess = {
   kind: "plan";
-  plan: ISemanticFixPlan;
+  plan: SemanticFixPlan;
 };
 
-export type ISemanticFixPlanSkip = {
+export type SemanticFixPlanSkip = {
   kind: "skip";
   reason: string;
 };
 
-export type ISemanticFixPlanResult = ISemanticFixPlanSkip | ISemanticFixPlanSuccess;
+export type SemanticFixPlanResult = SemanticFixPlanSkip | SemanticFixPlanSuccess;
 
-export type ISemanticFixProviderContext = {
+export type SemanticFixProviderContext = {
   targetDirectoryPath: string;
 };
 
-export type ISemanticFixProvider = {
-  createOperation: (
-    diagnostic: IOxlintDiagnostic,
-    context: ISemanticFixProviderContext,
-  ) => ISemanticFixOperation | null;
+export type SemanticFixProvider = {
+  createOperation: (diagnostic: OxlintDiagnostic, context: SemanticFixProviderContext) => SemanticFixOperation | null;
   ruleCode: string;
 };
 
-export type ISemanticFixBackendContext = {
+export type SemanticFixBackendContext = {
   targetDirectoryPath: string;
 };
 
-export type ISemanticFixBackend = {
-  createPlan: (
-    operation: ISemanticFixOperation,
-    context: ISemanticFixBackendContext,
-  ) => Promise<ISemanticFixPlanResult>;
+export type SemanticFixBackend = {
+  createPlan: (operation: SemanticFixOperation, context: SemanticFixBackendContext) => Promise<SemanticFixPlanResult>;
   dispose: () => Promise<void>;
   name: string;
 };
 
-export type IApplySemanticFixesProgressEvent =
+export type ApplySemanticFixesProgressEvent =
   | {
       kind: "running-oxlint";
       targetDirectoryPath: string;
@@ -139,25 +133,25 @@ export type IApplySemanticFixesProgressEvent =
       skippedDiagnosticCount: number;
     };
 
-export type IApplySemanticFixesOptions = {
+export type ApplySemanticFixesOptions = {
   dryRun?: boolean;
-  onProgress?: (event: IApplySemanticFixesProgressEvent) => void;
+  onProgress?: (event: ApplySemanticFixesProgressEvent) => void;
   oxlintConfigPath: string;
   oxlintExecutablePath: string;
   targetDirectoryPath: string;
   tsgoExecutablePath: string;
 };
 
-export type ISkippedDiagnostic = {
+export type SkippedDiagnostic = {
   filePath: string;
   reason: string;
   ruleCode: string;
 };
 
-export type IApplySemanticFixesResult = {
+export type ApplySemanticFixesResult = {
   appliedFileCount: number;
   backendName: string;
   changedFilePaths: readonly string[];
   plannedFixCount: number;
-  skippedDiagnostics: readonly ISkippedDiagnostic[];
+  skippedDiagnostics: readonly SkippedDiagnostic[];
 };