@alexgorbatchev/typescript-ai-policy 0.1.0

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

@@ -0,0 +1,439 @@
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { pathToFileURL } from "node:url";
+import type { ILineAndCharacter } from "../../types.ts";
+
+type IJsonRpcIdentifier = number | string | null;
+
+type IJsonRpcError = {
+  code: number;
+  message: string;
+};
+
+type IJsonRpcErrorResponse = {
+  error: IJsonRpcError;
+  id: IJsonRpcIdentifier;
+  jsonrpc: string;
+};
+
+type IJsonRpcRequestMessage = {
+  id?: IJsonRpcIdentifier;
+  jsonrpc: string;
+  method: string;
+  params?: unknown;
+};
+
+type IJsonRpcSuccessResponse = {
+  id: IJsonRpcIdentifier;
+  jsonrpc: string;
+  result?: unknown;
+};
+
+type IJsonRpcResponse = IJsonRpcErrorResponse | IJsonRpcSuccessResponse;
+
+type ILspTextDocumentIdentifier = {
+  uri: string;
+};
+
+type ILspPosition = {
+  character: number;
+  line: number;
+};
+
+type ILspWorkspaceFolder = {
+  name: string;
+  uri: string;
+};
+
+type ILspWorkspaceEditCapabilities = {
+  documentChanges: boolean;
+};
+
+type ILspWorkspaceCapabilities = {
+  workspaceEdit: ILspWorkspaceEditCapabilities;
+};
+
+type ILspRenameCapabilities = {
+  prepareSupport: boolean;
+};
+
+type ILspTextDocumentCapabilities = {
+  rename: ILspRenameCapabilities;
+};
+
+type ILspClientCapabilities = {
+  textDocument: ILspTextDocumentCapabilities;
+  workspace: ILspWorkspaceCapabilities;
+};
+
+type ILspInitializeParams = {
+  capabilities: ILspClientCapabilities;
+  processId: number;
+  rootUri: string;
+  workspaceFolders: readonly ILspWorkspaceFolder[];
+};
+
+type ILspPrepareRenameParams = {
+  position: ILspPosition;
+  textDocument: ILspTextDocumentIdentifier;
+};
+
+type ILspRenameParams = {
+  newName: string;
+  position: ILspPosition;
+  textDocument: ILspTextDocumentIdentifier;
+};
+
+type ITsgoLspClientOptions = {
+  tsgoExecutablePath: string;
+  workspacePath: string;
+};
+
+type IPendingRequest = {
+  reject: (error: Error) => void;
+  resolve: (result: unknown) => void;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isJsonRpcError(value: unknown): value is IJsonRpcError {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  return typeof value.code === "number" && typeof value.message === "string";
+}
+
+function isJsonRpcRequestMessage(value: unknown): value is IJsonRpcRequestMessage {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  return value.jsonrpc === "2.0" && typeof value.method === "string";
+}
+
+function isJsonRpcResponse(value: unknown): value is IJsonRpcResponse {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  if (value.jsonrpc !== "2.0") {
+    return false;
+  }
+
+  const hasIdentifier = typeof value.id === "number" || typeof value.id === "string" || value.id === null;
+  if (!hasIdentifier) {
+    return false;
+  }
+
+  if (Reflect.has(value, "error")) {
+    return isJsonRpcError(value.error);
+  }
+
+  return Reflect.has(value, "result");
+}
+
+function readLspPosition(position: ILineAndCharacter): ILspPosition {
+  return {
+    character: position.character,
+    line: position.line,
+  };
+}
+
+export class TsgoLspClient {
+  private readonly pendingRequests = new Map<number, IPendingRequest>();
+  private readonly process: ReturnType<typeof spawn>;
+  private readonly stderrChunks: string[] = [];
+  private stdoutBuffer = Buffer.alloc(0);
+  private requestId = 0;
+
+  public constructor(private readonly options: ITsgoLspClientOptions) {
+    this.process = spawn(this.options.tsgoExecutablePath, ["--lsp", "--stdio"], {
+      cwd: this.options.workspacePath,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    const stdoutStream = this.process.stdout;
+    if (!stdoutStream) {
+      throw new Error("tsgo LSP stdout is unavailable");
+    }
+
+    const stderrStream = this.process.stderr;
+    if (!stderrStream) {
+      throw new Error("tsgo LSP stderr is unavailable");
+    }
+
+    stdoutStream.on("data", (chunk: Buffer) => {
+      this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, chunk]);
+      this.consumeOutputBuffer();
+    });
+
+    stderrStream.on("data", (chunk: Buffer) => {
+      this.stderrChunks.push(chunk.toString("utf8"));
+    });
+
+    this.process.on("error", (error: Error) => {
+      this.rejectPendingRequests(error);
+    });
+
+    this.process.on("close", (code: number | null, signal: NodeJS.Signals | null) => {
+      const stderrOutput = this.readStderrOutput();
+      const failureReason = `tsgo LSP exited before the request completed (code=${String(code)}, signal=${String(signal)})${stderrOutput}`;
+      this.rejectPendingRequests(new Error(failureReason));
+    });
+  }
+
+  public async initialize(): Promise<void> {
+    const rootUri = pathToFileURL(this.options.workspacePath).toString();
+    const initializeParams: ILspInitializeParams = {
+      capabilities: {
+        textDocument: {
+          rename: {
+            prepareSupport: true,
+          },
+        },
+        workspace: {
+          workspaceEdit: {
+            documentChanges: false,
+          },
+        },
+      },
+      processId: process.pid,
+      rootUri,
+      workspaceFolders: [
+        {
+          name: "workspace",
+          uri: rootUri,
+        },
+      ],
+    };
+
+    await this.sendRequest("initialize", initializeParams);
+    this.sendNotification("initialized");
+  }
+
+  public prepareRename(filePath: string, position: ILineAndCharacter): Promise<unknown> {
+    const params: ILspPrepareRenameParams = {
+      position: readLspPosition(position),
+      textDocument: {
+        uri: pathToFileURL(filePath).toString(),
+      },
+    };
+
+    return this.sendRequest("textDocument/prepareRename", params);
+  }
+
+  public rename(filePath: string, position: ILineAndCharacter, newName: string): Promise<unknown> {
+    const params: ILspRenameParams = {
+      newName,
+      position: readLspPosition(position),
+      textDocument: {
+        uri: pathToFileURL(filePath).toString(),
+      },
+    };
+
+    return this.sendRequest("textDocument/rename", params);
+  }
+
+  public async dispose(): Promise<void> {
+    try {
+      await this.sendRequest("shutdown");
+    } catch {
+      // The caller wants disposal to be best-effort.
+    }
+
+    this.sendNotification("exit");
+
+    const stdinStream = this.process.stdin;
+    if (stdinStream && !stdinStream.destroyed) {
+      stdinStream.end();
+    }
+
+    await this.waitForClose(1000);
+  }
+
+  private consumeOutputBuffer(): void {
+    while (true) {
+      const headerEnd = this.stdoutBuffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) {
+        return;
+      }
+
+      const headerText = this.stdoutBuffer.subarray(0, headerEnd).toString("utf8");
+      const contentLength = this.readContentLength(headerText);
+      const messageStart = headerEnd + 4;
+      const messageEnd = messageStart + contentLength;
+
+      if (this.stdoutBuffer.length < messageEnd) {
+        return;
+      }
+
+      const messageText = this.stdoutBuffer.subarray(messageStart, messageEnd).toString("utf8");
+      this.stdoutBuffer = this.stdoutBuffer.subarray(messageEnd);
+
+      const parsedMessage: unknown = JSON.parse(messageText);
+      this.handleMessage(parsedMessage);
+    }
+  }
+
+  private handleMessage(message: unknown): void {
+    if (isJsonRpcResponse(message)) {
+      this.handleResponse(message);
+      return;
+    }
+
+    if (isJsonRpcRequestMessage(message)) {
+      this.handleServerRequest(message);
+    }
+  }
+
+  private handleResponse(message: IJsonRpcResponse): void {
+    if (typeof message.id !== "number") {
+      return;
+    }
+
+    const pendingRequest = this.pendingRequests.get(message.id);
+    if (!pendingRequest) {
+      return;
+    }
+
+    this.pendingRequests.delete(message.id);
+
+    if ("error" in message) {
+      pendingRequest.reject(new Error(`${message.error.message} (code=${String(message.error.code)})`));
+      return;
+    }
+
+    pendingRequest.resolve(message.result ?? null);
+  }
+
+  private handleServerRequest(message: IJsonRpcRequestMessage): void {
+    if (message.id === undefined) {
+      return;
+    }
+
+    this.writeResponse(message.id, this.readServerRequestResult(message.method));
+  }
+
+  private readContentLength(headerText: string): number {
+    const headerLines = headerText.split("\r\n");
+
+    for (const headerLine of headerLines) {
+      const lowerCasedHeaderLine = headerLine.toLowerCase();
+      if (!lowerCasedHeaderLine.startsWith("content-length:")) {
+        continue;
+      }
+
+      const rawValue = headerLine.slice("content-length:".length).trim();
+      const contentLength = Number(rawValue);
+      if (!Number.isInteger(contentLength) || contentLength < 0) {
+        throw new Error(`Invalid Content-Length header: ${headerLine}`);
+      }
+
+      return contentLength;
+    }
+
+    throw new Error(`Missing Content-Length header: ${headerText}`);
+  }
+
+  private readServerRequestResult(method: string): unknown {
+    switch (method) {
+      case "client/registerCapability":
+        return null;
+      case "workspace/configuration":
+        return [];
+      default:
+        return null;
+    }
+  }
+
+  private readStderrOutput(): string {
+    const stderrOutput = this.stderrChunks.join("").trim();
+    if (stderrOutput.length === 0) {
+      return "";
+    }
+
+    return `\n\nStderr:\n${stderrOutput}`;
+  }
+
+  private rejectPendingRequests(error: Error): void {
+    for (const [requestId, pendingRequest] of this.pendingRequests) {
+      this.pendingRequests.delete(requestId);
+      pendingRequest.reject(error);
+    }
+  }
+
+  private sendNotification(method: string, params?: unknown): void {
+    this.writeMessage(method, undefined, params);
+  }
+
+  private sendRequest(method: string, params?: unknown): Promise<unknown> {
+    const requestId = this.requestId;
+    this.requestId += 1;
+
+    const responsePromise = new Promise<unknown>((resolve, reject) => {
+      this.pendingRequests.set(requestId, {
+        reject,
+        resolve,
+      });
+    });
+
+    this.writeMessage(method, requestId, params);
+
+    return responsePromise;
+  }
+
+  private async waitForClose(timeoutMs: number): Promise<void> {
+    if (this.process.exitCode !== null || this.process.signalCode !== null) {
+      return;
+    }
+
+    const closePromise = once(this.process, "close").then(() => undefined);
+    const killTimer = setTimeout(() => {
+      if (this.process.exitCode === null && this.process.signalCode === null) {
+        this.process.kill("SIGKILL");
+      }
+    }, timeoutMs);
+
+    await closePromise;
+    clearTimeout(killTimer);
+  }
+
+  private writeMessage(method: string, id?: IJsonRpcIdentifier, params?: unknown): void {
+    const message: Record<string, unknown> = {
+      jsonrpc: "2.0",
+      method,
+    };
+
+    if (id !== undefined) {
+      message.id = id;
+    }
+
+    if (params !== undefined) {
+      message.params = params;
+    }
+
+    this.writeSerializedMessage(message);
+  }
+
+  private writeResponse(id: IJsonRpcIdentifier, result: unknown): void {
+    this.writeSerializedMessage({
+      id,
+      jsonrpc: "2.0",
+      result,
+    });
+  }
+
+  private writeSerializedMessage(message: Record<string, unknown>): void {
+    const stdinStream = this.process.stdin;
+    if (!stdinStream || stdinStream.destroyed) {
+      throw new Error(`Cannot write to tsgo LSP stdin${this.readStderrOutput()}`);
+    }
+
+    const serializedMessage = JSON.stringify(message);
+    const contentLength = Buffer.byteLength(serializedMessage, "utf8");
+    stdinStream.write(`Content-Length: ${String(contentLength)}\r\n\r\n${serializedMessage}`);
+  }
+}

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

@@ -0,0 +1,251 @@
+import { existsSync } from "node:fs";
+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,
+} from "../../types.ts";
+
+type ILspPosition = {
+  character: number;
+  line: number;
+};
+
+type ILspRange = {
+  end: ILspPosition;
+  start: ILspPosition;
+};
+
+type ILspTextEdit = {
+  newText: string;
+  range: ILspRange;
+};
+
+type ILspWorkspaceChanges = Record<string, readonly ILspTextEdit[]>;
+
+type ILspWorkspaceEdit = {
+  changes: ILspWorkspaceChanges;
+};
+
+type IClientCache = 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 {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  return typeof value.line === "number" && typeof value.character === "number";
+}
+
+function isLspRange(value: unknown): value is ILspRange {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  return isLspPosition(value.start) && isLspPosition(value.end);
+}
+
+function isLspTextEdit(value: unknown): value is ILspTextEdit {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  return typeof value.newText === "string" && isLspRange(value.range);
+}
+
+function isLspWorkspaceEdit(value: unknown): value is ILspWorkspaceEdit {
+  if (!isRecord(value) || !isRecord(value.changes)) {
+    return false;
+  }
+
+  for (const textEdits of Object.values(value.changes)) {
+    if (!Array.isArray(textEdits)) {
+      return false;
+    }
+
+    for (const textEdit of textEdits) {
+      if (!isLspTextEdit(textEdit)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+function compareTextEdit(left: ITextEdit, right: ITextEdit): number {
+  if (left.filePath !== right.filePath) {
+    return left.filePath.localeCompare(right.filePath);
+  }
+
+  if (left.start.line !== right.start.line) {
+    return left.start.line - right.start.line;
+  }
+
+  if (left.start.character !== right.start.character) {
+    return left.start.character - right.start.character;
+  }
+
+  return left.newText.localeCompare(right.newText);
+}
+
+function readTextEdit(uri: string, textEdit: ILspTextEdit): ITextEdit {
+  return {
+    end: textEdit.range.end,
+    filePath: fileURLToPath(uri),
+    newText: textEdit.newText,
+    start: textEdit.range.start,
+  };
+}
+
+function readTextEdits(workspaceEdit: ILspWorkspaceEdit): readonly ITextEdit[] {
+  const textEdits: ITextEdit[] = [];
+
+  for (const [uri, edits] of Object.entries(workspaceEdit.changes)) {
+    for (const textEdit of edits) {
+      textEdits.push(readTextEdit(uri, textEdit));
+    }
+  }
+
+  return textEdits.sort(compareTextEdit);
+}
+
+function readFailureReason(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  return String(error);
+}
+
+async function readClient(
+  clientCache: IClientCache,
+  context: ISemanticFixBackendContext,
+  options: Pick<IApplySemanticFixesOptions, "tsgoExecutablePath">,
+): Promise<TsgoLspClient> {
+  const cachedClient = clientCache.get(context.targetDirectoryPath);
+  if (cachedClient) {
+    return cachedClient;
+  }
+
+  const client = new TsgoLspClient({
+    tsgoExecutablePath: options.tsgoExecutablePath,
+    workspacePath: context.targetDirectoryPath,
+  });
+  await client.initialize();
+  clientCache.set(context.targetDirectoryPath, client);
+  return client;
+}
+
+function readRenameSymbolDescription(operation: ISymbolRenameOperation): string {
+  return `Rename ${operation.symbolName} to ${operation.newName}`;
+}
+
+function readMoveFileDescription(operation: IMoveFileOperation): string {
+  return `Move ${operation.filePath} to ${operation.newFilePath}`;
+}
+
+function readPlan(
+  operation: ISemanticFixOperation,
+  textEdits: readonly ITextEdit[],
+  fileMoves: readonly IFileMove[] = [],
+): ISemanticFixPlan {
+  return {
+    description:
+      operation.kind === "rename-symbol" ? readRenameSymbolDescription(operation) : readMoveFileDescription(operation),
+    fileMoves,
+    operationId: operation.id,
+    ruleCode: operation.ruleCode,
+    textEdits,
+  };
+}
+
+export function createTsgoLspSemanticFixBackend(
+  options: Pick<IApplySemanticFixesOptions, "tsgoExecutablePath">,
+): ISemanticFixBackend {
+  const clientCache: IClientCache = new Map();
+
+  return {
+    async createPlan(operation, context): Promise<ISemanticFixPlanResult> {
+      switch (operation.kind) {
+        case "rename-symbol": {
+          const client = await readClient(clientCache, context, options);
+
+          try {
+            await client.prepareRename(operation.filePath, operation.position);
+          } catch (error) {
+            return {
+              kind: "skip",
+              reason: readFailureReason(error),
+            };
+          }
+
+          let renameResult: unknown;
+
+          try {
+            renameResult = await client.rename(operation.filePath, operation.position, operation.newName);
+          } catch (error) {
+            return {
+              kind: "skip",
+              reason: readFailureReason(error),
+            };
+          }
+          if (renameResult === null) {
+            return {
+              kind: "skip",
+              reason: `tsgo returned no edits for ${operation.symbolName}`,
+            };
+          }
+
+          if (!isLspWorkspaceEdit(renameResult)) {
+            throw new Error(`Unexpected tsgo rename response: ${JSON.stringify(renameResult)}`);
+          }
+
+          return {
+            kind: "plan",
+            plan: readPlan(operation, readTextEdits(renameResult)),
+          };
+        }
+        case "move-file": {
+          if (existsSync(operation.newFilePath)) {
+            return {
+              kind: "skip",
+              reason: `Cannot move test file because the canonical destination already exists: ${operation.newFilePath}`,
+            };
+          }
+
+          return {
+            kind: "plan",
+            plan: readPlan(operation, readMovedFileTextEdits(operation.filePath, operation.newFilePath), [
+              {
+                destinationFilePath: operation.newFilePath,
+                sourceFilePath: operation.filePath,
+              },
+            ]),
+          };
+        }
+      }
+    },
+    async dispose(): Promise<void> {
+      for (const client of clientCache.values()) {
+        await client.dispose();
+      }
+
+      clientCache.clear();
+    },
+    name: "tsgo-lsp+native",
+  };
+}