@alexgorbatchev/typescript-ai-policy 0.1.0

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

@@ -0,0 +1,132 @@
+import { readFileSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import ts from "typescript";
+import type {
+  IOxlintDiagnostic,
+  ISemanticFixOperation,
+  ISemanticFixProvider,
+  ISemanticFixProviderContext,
+} 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);
+}
+
+function readNormalizedInterfaceName(interfaceName: string): string | null {
+  const rawBaseName = /^[Ii]/.test(interfaceName) ? interfaceName.slice(1) : interfaceName;
+  if (!/^[A-Za-z][A-Za-z0-9]*$/.test(rawBaseName)) {
+    return null;
+  }
+
+  const normalizedBaseName = rawBaseName.charAt(0).toUpperCase() + rawBaseName.slice(1);
+  const normalizedInterfaceName = `I${normalizedBaseName}`;
+
+  if (normalizedInterfaceName === interfaceName) {
+    return null;
+  }
+
+  return normalizedInterfaceName;
+}
+
+function readOperation(
+  diagnostic: IOxlintDiagnostic,
+  context: ISemanticFixProviderContext,
+): ISemanticFixOperation | 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);
+  if (!interfaceDeclaration) {
+    return null;
+  }
+
+  const symbolName = interfaceDeclaration.name.text;
+  const newName = readNormalizedInterfaceName(symbolName);
+  if (!newName) {
+    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,
+  };
+}
+
+export function createInterfaceNamingConventionSemanticFixProvider(): ISemanticFixProvider {
+  return {
+    createOperation(diagnostic, context): ISemanticFixOperation | null {
+      return readOperation(diagnostic, context);
+    },
+    ruleCode: "@alexgorbatchev/interface-naming-convention",
+  };
+}

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

@@ -0,0 +1,52 @@
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import type {
+  IOxlintDiagnostic,
+  ISemanticFixOperation,
+  ISemanticFixProvider,
+  ISemanticFixProviderContext,
+} from "../types.ts";
+
+const REQUIRED_TEST_FILE_NAME_PATTERN = /\.test\.tsx?$/u;
+const TESTS_DIRECTORY_PATH_PATTERN = /(^|\/)__tests__(\/|$)/u;
+
+function readAbsoluteDiagnosticFilePath(diagnostic: IOxlintDiagnostic, context: ISemanticFixProviderContext): string {
+  if (isAbsolute(diagnostic.filename)) {
+    return diagnostic.filename;
+  }
+
+  return resolve(context.targetDirectoryPath, diagnostic.filename);
+}
+
+function isInTestsDirectory(filePath: string): boolean {
+  return TESTS_DIRECTORY_PATH_PATTERN.test(filePath.replaceAll("\\", "/"));
+}
+
+function readOperation(
+  diagnostic: IOxlintDiagnostic,
+  context: ISemanticFixProviderContext,
+): ISemanticFixOperation | null {
+  const filePath = readAbsoluteDiagnosticFilePath(diagnostic, context);
+  const baseName = basename(filePath);
+  if (!REQUIRED_TEST_FILE_NAME_PATTERN.test(baseName) || isInTestsDirectory(filePath)) {
+    return null;
+  }
+
+  const newFilePath = join(dirname(filePath), "__tests__", baseName);
+
+  return {
+    filePath,
+    id: `${diagnostic.code}:${filePath}:${newFilePath}`,
+    kind: "move-file",
+    newFilePath,
+    ruleCode: diagnostic.code,
+  };
+}
+
+export function createTestFileLocationConventionSemanticFixProvider(): ISemanticFixProvider {
+  return {
+    createOperation(diagnostic, context): ISemanticFixOperation | null {
+      return readOperation(diagnostic, context);
+    },
+    ruleCode: "@alexgorbatchev/test-file-location-convention",
+  };
+}

package/src/semantic-fixes/readMovedFileTextEdits.ts

@@ -0,0 +1,150 @@
+import { dirname, relative, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import ts from "typescript";
+import type { ITextEdit } from "./types.ts";
+
+function isRelativeModuleSpecifier(moduleSpecifier: string): boolean {
+  return (
+    moduleSpecifier === "." ||
+    moduleSpecifier === ".." ||
+    moduleSpecifier.startsWith("./") ||
+    moduleSpecifier.startsWith("../")
+  );
+}
+
+function normalizePathSlashes(filePath: string): string {
+  return filePath.replaceAll("\\", "/");
+}
+
+function readRelativeModuleSpecifier(fromDirectoryPath: string, targetPath: string): string {
+  const relativePath = normalizePathSlashes(relative(fromDirectoryPath, targetPath));
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+
+type IModuleSpecifierEntry = {
+  moduleSpecifier: string;
+  node: ts.StringLiteralLike;
+};
+
+function readImportTypeArgumentLiteral(node: ts.ImportTypeNode): ts.StringLiteralLike | null {
+  if (!ts.isLiteralTypeNode(node.argument)) {
+    return null;
+  }
+
+  return ts.isStringLiteralLike(node.argument.literal) ? node.argument.literal : null;
+}
+
+function readModuleSpecifierEntry(node: ts.Node): IModuleSpecifierEntry | null {
+  if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+    return node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)
+      ? {
+          moduleSpecifier: node.moduleSpecifier.text,
+          node: node.moduleSpecifier,
+        }
+      : null;
+  }
+
+  if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference)) {
+    const expression = node.moduleReference.expression;
+    return expression && ts.isStringLiteralLike(expression)
+      ? {
+          moduleSpecifier: expression.text,
+          node: expression,
+        }
+      : null;
+  }
+
+  if (ts.isImportTypeNode(node)) {
+    const argumentLiteral = readImportTypeArgumentLiteral(node);
+    return argumentLiteral
+      ? {
+          moduleSpecifier: argumentLiteral.text,
+          node: argumentLiteral,
+        }
+      : null;
+  }
+
+  if (ts.isCallExpression(node)) {
+    const firstArgument = node.arguments[0];
+    if (!firstArgument || !ts.isStringLiteralLike(firstArgument)) {
+      return null;
+    }
+
+    if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      return {
+        moduleSpecifier: firstArgument.text,
+        node: firstArgument,
+      };
+    }
+
+    if (ts.isIdentifier(node.expression) && node.expression.text === "require") {
+      return {
+        moduleSpecifier: firstArgument.text,
+        node: firstArgument,
+      };
+    }
+  }
+
+  return null;
+}
+
+function readModuleSpecifierEntries(sourceFile: ts.SourceFile): readonly IModuleSpecifierEntry[] {
+  const moduleSpecifierEntries: IModuleSpecifierEntry[] = [];
+
+  function visitNode(node: ts.Node): void {
+    const moduleSpecifierEntry = readModuleSpecifierEntry(node);
+    if (moduleSpecifierEntry) {
+      moduleSpecifierEntries.push(moduleSpecifierEntry);
+    }
+
+    ts.forEachChild(node, visitNode);
+  }
+
+  visitNode(sourceFile);
+
+  return moduleSpecifierEntries;
+}
+
+export function readMovedFileTextEdits(sourceFilePath: string, destinationFilePath: string): readonly ITextEdit[] {
+  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[] = [];
+
+  for (const moduleSpecifierEntry of readModuleSpecifierEntries(sourceFile)) {
+    if (!isRelativeModuleSpecifier(moduleSpecifierEntry.moduleSpecifier)) {
+      continue;
+    }
+
+    const resolvedImportTargetPath = resolve(sourceDirectoryPath, moduleSpecifierEntry.moduleSpecifier);
+    const updatedModuleSpecifier = readRelativeModuleSpecifier(destinationDirectoryPath, resolvedImportTargetPath);
+    if (updatedModuleSpecifier === moduleSpecifierEntry.moduleSpecifier) {
+      continue;
+    }
+
+    const start = ts.getLineAndCharacterOfPosition(sourceFile, moduleSpecifierEntry.node.getStart(sourceFile) + 1);
+    const end = ts.getLineAndCharacterOfPosition(sourceFile, moduleSpecifierEntry.node.getEnd() - 1);
+
+    textEdits.push({
+      end: {
+        character: end.character,
+        line: end.line,
+      },
+      filePath: sourceFilePath,
+      newText: updatedModuleSpecifier,
+      start: {
+        character: start.character,
+        line: start.line,
+      },
+    });
+  }
+
+  return textEdits.sort((left, right) => {
+    if (left.start.line !== right.start.line) {
+      return left.start.line - right.start.line;
+    }
+
+    return left.start.character - right.start.character;
+  });
+}

package/src/semantic-fixes/readSemanticFixRuntimePaths.ts

@@ -0,0 +1,38 @@
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export type ISemanticFixRuntimePaths = {
+  oxlintConfigPath: string;
+  oxlintExecutablePath: string;
+  tsgoExecutablePath: string;
+};
+
+const require = createRequire(import.meta.url);
+const packageRootPath = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+
+function readInstalledPackageRootPath(packageName: string, resolutionFailureMessage: string): string {
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`);
+    return dirname(packageJsonPath);
+  } catch {
+    throw new Error(resolutionFailureMessage);
+  }
+}
+
+export function readSemanticFixRuntimePaths(): ISemanticFixRuntimePaths {
+  const oxlintPackageRootPath = readInstalledPackageRootPath(
+    "oxlint",
+    'Missing peer dependency "oxlint". Install oxlint in the consuming project so the semantic-fix CLI can run repository policy checks.',
+  );
+  const tsgoPackageRootPath = readInstalledPackageRootPath(
+    "@typescript/native-preview",
+    'Missing peer dependency "@typescript/native-preview". Install @typescript/native-preview in the consuming project to use the semantic-fix CLI.',
+  );
+
+  return {
+    oxlintConfigPath: resolve(packageRootPath, "src/oxlint/oxlint.config.ts"),
+    oxlintExecutablePath: resolve(oxlintPackageRootPath, "bin/oxlint"),
+    tsgoExecutablePath: resolve(tsgoPackageRootPath, "bin/tsgo.js"),
+  };
+}

package/src/semantic-fixes/runApplySemanticFixes.ts

@@ -0,0 +1,120 @@
+#!/usr/bin/env bun
+
+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";
+
+type ICliOptions = {
+  dryRun: boolean;
+  targetDirectoryPath: string;
+};
+
+const SEMANTIC_FIX_BIN_NAME = "typescript-ai-policy-fix-semantic";
+
+function readUsageText(): string {
+  return [
+    "Usage:",
+    `  ${SEMANTIC_FIX_BIN_NAME} <target-directory> [--dry-run]`,
+    "  bun run fix:semantic -- <target-directory> [--dry-run]",
+    "",
+    "Examples:",
+    `  ${SEMANTIC_FIX_BIN_NAME} .`,
+    `  ${SEMANTIC_FIX_BIN_NAME} /path/to/project --dry-run`,
+    "  bun run fix:semantic -- .",
+  ].join("\n");
+}
+
+function readCliOptions(argv: readonly string[]): ICliOptions {
+  const remainingArguments = argv.slice(2);
+  const targetDirectoryArgument = remainingArguments.find((argument) => !argument.startsWith("-"));
+  if (!targetDirectoryArgument) {
+    throw new Error(readUsageText());
+  }
+
+  const targetDirectoryPath = resolve(targetDirectoryArgument);
+  if (!existsSync(targetDirectoryPath)) {
+    throw new Error(`Target directory does not exist: ${targetDirectoryPath}`);
+  }
+
+  if (!statSync(targetDirectoryPath).isDirectory()) {
+    throw new Error(`Target path is not a directory: ${targetDirectoryPath}`);
+  }
+
+  return {
+    dryRun: remainingArguments.includes("--dry-run"),
+    targetDirectoryPath,
+  };
+}
+
+function readDisplayPath(targetDirectoryPath: string, filePath: string): string {
+  const absoluteFilePath = isAbsolute(filePath) ? filePath : resolve(targetDirectoryPath, filePath);
+  const relativeFilePath = relative(targetDirectoryPath, absoluteFilePath);
+  return relativeFilePath.length > 0 ? relativeFilePath : ".";
+}
+
+function formatSkippedDiagnostic(targetDirectoryPath: string, skippedDiagnostic: ISkippedDiagnostic): string {
+  return `- [${skippedDiagnostic.ruleCode}] ${readDisplayPath(targetDirectoryPath, skippedDiagnostic.filePath)}: ${skippedDiagnostic.reason}`;
+}
+
+function formatProgressEvent(event: IApplySemanticFixesProgressEvent): string {
+  switch (event.kind) {
+    case "running-oxlint": {
+      return "running oxlint...";
+    }
+    case "collected-diagnostics": {
+      return `semantic-fix diagnostics: ${String(event.diagnosticCount)}`;
+    }
+    case "planning-start": {
+      return `planning semantic fixes: ${String(event.operationCount)} candidate operation(s)`;
+    }
+    case "planning-operation": {
+      return `planning semantic fix ${String(event.operationIndex)}/${String(event.operationCount)}: ${event.description}`;
+    }
+    case "applying-file-changes": {
+      const modeLabel = event.dryRun ? "dry run" : "applying changes";
+      return `${modeLabel}: ${String(event.textEditCount)} text edit(s) and ${String(event.moveCount)} file move(s) across ${String(event.fileCount)} file(s)`;
+    }
+    case "complete": {
+      return `semantic fix complete: ${String(event.plannedFixCount)} plan(s), ${String(event.changedFileCount)} changed file(s), ${String(event.skippedDiagnosticCount)} skipped diagnostic(s)`;
+    }
+  }
+}
+
+try {
+  const cliOptions = readCliOptions(process.argv);
+  const runtimePaths = readSemanticFixRuntimePaths();
+  const result = await applySemanticFixes({
+    dryRun: cliOptions.dryRun,
+    onProgress(event) {
+      console.log(formatProgressEvent(event));
+    },
+    oxlintConfigPath: runtimePaths.oxlintConfigPath,
+    oxlintExecutablePath: runtimePaths.oxlintExecutablePath,
+    targetDirectoryPath: cliOptions.targetDirectoryPath,
+    tsgoExecutablePath: runtimePaths.tsgoExecutablePath,
+  });
+
+  console.log(`backend: ${result.backendName}`);
+  console.log(`planned fixes: ${String(result.plannedFixCount)}`);
+  console.log(`applied files: ${String(result.appliedFileCount)}`);
+
+  if (result.changedFilePaths.length > 0) {
+    console.log("changed files:");
+    for (const changedFilePath of result.changedFilePaths) {
+      console.log(`- ${readDisplayPath(cliOptions.targetDirectoryPath, changedFilePath)}`);
+    }
+  }
+
+  if (result.skippedDiagnostics.length > 0) {
+    console.log("skipped diagnostics:");
+    for (const skippedDiagnostic of result.skippedDiagnostics) {
+      console.log(formatSkippedDiagnostic(cliOptions.targetDirectoryPath, skippedDiagnostic));
+    }
+  }
+} catch (error) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  console.error(errorMessage);
+  process.exitCode = 1;
+}

package/src/semantic-fixes/runOxlintJson.ts

@@ -0,0 +1,139 @@
+import { closeSync, openSync } from "node:fs";
+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";
+
+type IRunOxlintJsonOptions = {
+  oxlintConfigPath: string;
+  oxlintExecutablePath: string;
+  targetDirectoryPath: string;
+};
+
+type IOxlintProcessCompletion = {
+  exitCode: number | null;
+  signal: NodeJS.Signals | null;
+};
+
+type IOxlintProcessResult = IOxlintProcessCompletion & {
+  stderr: string;
+  stdout: string;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isOxlintDiagnostic(value: unknown): value is IOxlintDiagnostic {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  return (
+    typeof value.code === "string" &&
+    typeof value.filename === "string" &&
+    Array.isArray(value.labels) &&
+    typeof value.message === "string" &&
+    typeof value.severity === "string"
+  );
+}
+
+function readNormalizedRuleCode(ruleCode: string): string {
+  const normalizedRuleCodeMatch = /^(@[^()]+)\(([^()]+)\)$/.exec(ruleCode);
+  if (!normalizedRuleCodeMatch) {
+    return ruleCode;
+  }
+
+  const [, pluginName, localRuleName] = normalizedRuleCodeMatch;
+  return `${pluginName}/${localRuleName}`;
+}
+
+function readDiagnostics(report: unknown): readonly IOxlintDiagnostic[] {
+  if (!isRecord(report) || !Array.isArray(report.diagnostics)) {
+    throw new Error(`Unexpected Oxlint JSON output: ${JSON.stringify(report)}`);
+  }
+
+  const diagnostics = report.diagnostics.filter(isOxlintDiagnostic);
+  if (diagnostics.length !== report.diagnostics.length) {
+    throw new Error(`Unexpected Oxlint diagnostic payload: ${JSON.stringify(report)}`);
+  }
+
+  return diagnostics.map((diagnostic) => ({
+    ...diagnostic,
+    code: readNormalizedRuleCode(diagnostic.code),
+  }));
+}
+
+async function runOxlintProcess(options: IRunOxlintJsonOptions): Promise<IOxlintProcessResult> {
+  const tempDirectoryPath = await mkdtemp(join(tmpdir(), "semantic-fixes-oxlint-"));
+  const stdoutPath = join(tempDirectoryPath, "oxlint-report.json");
+  const stdoutFileDescriptor = openSync(stdoutPath, "w");
+
+  try {
+    let childProcess: ReturnType<typeof spawn>;
+
+    try {
+      childProcess = spawn(
+        options.oxlintExecutablePath,
+        ["--config", options.oxlintConfigPath, "--disable-nested-config", "--format", "json", "."],
+        {
+          cwd: options.targetDirectoryPath,
+          stdio: ["ignore", stdoutFileDescriptor, "pipe"],
+        },
+      );
+    } finally {
+      closeSync(stdoutFileDescriptor);
+    }
+
+    const stderrChunks: string[] = [];
+    const stderrStream = childProcess.stderr;
+    if (!stderrStream) {
+      throw new Error("Oxlint stderr stream is unavailable.");
+    }
+
+    stderrStream.on("data", (chunk: Buffer) => {
+      stderrChunks.push(chunk.toString("utf8"));
+    });
+
+    const processCompletion = await new Promise<IOxlintProcessCompletion>((resolve, reject) => {
+      childProcess.once("error", (error: Error) => {
+        reject(error);
+      });
+      childProcess.once("close", (exitCode: number | null, signal: NodeJS.Signals | null) => {
+        resolve({ exitCode, signal });
+      });
+    });
+
+    const stdout = await readFile(stdoutPath, "utf8");
+
+    return {
+      exitCode: processCompletion.exitCode,
+      signal: processCompletion.signal,
+      stderr: stderrChunks.join("").trim(),
+      stdout,
+    };
+  } finally {
+    await rm(tempDirectoryPath, { force: true, recursive: true });
+  }
+}
+
+export async function runOxlintJson(options: IRunOxlintJsonOptions): Promise<readonly IOxlintDiagnostic[]> {
+  const runResult = await runOxlintProcess(options);
+  const stdout = runResult.stdout.trim();
+  if (stdout.length === 0) {
+    throw new Error(`Oxlint returned no JSON output.\n\nStderr:\n${runResult.stderr}`);
+  }
+
+  const parsedOutput: unknown = JSON.parse(stdout);
+  const diagnostics = readDiagnostics(parsedOutput);
+
+  if (runResult.exitCode !== 0 && runResult.exitCode !== 1) {
+    const signalSuffix = runResult.signal ? `, signal=${runResult.signal}` : "";
+    throw new Error(
+      `Oxlint failed with exit code ${String(runResult.exitCode)}${signalSuffix}.\n\nStderr:\n${runResult.stderr}`,
+    );
+  }
+
+  return diagnostics;
+}