@mrclrchtr/supi-code-intelligence 4.10.0 → 5.0.0

package/node_modules/@mrclrchtr/supi-lsp/src/provider/refactor-planning.ts

@@ -1,38 +1,49 @@
-import type { CodePosition, RefactorResult, SourceRange } from "@mrclrchtr/supi-code-runtime/api";
-import { uriToFile } from "@mrclrchtr/supi-core/path";
-import type { CodeAction, TextDocumentEdit, TextEdit, WorkspaceEdit } from "../config/types.ts";
+import type {
+  CodePosition,
+  CodeRequestControl,
+  RefactorResult,
+  SourceRange,
+} from "@mrclrchtr/supi-code-runtime/api";
+import type { CodeAction } from "../config/types.ts";
 import type { WorkspaceLspRuntime } from "../session/runtime-registry.ts";
+import {
+  normalizeSemanticEdit,
+  type SemanticEditNormalizationContext,
+} from "./semantic-edit-normalizer.ts";
 
-export async function runRenameRefactor(
-  lsp: WorkspaceLspRuntime,
-  file: string,
-  position: CodePosition,
-  newName: string,
-): Promise<RefactorResult> {
-  const edit = await lsp.rename(file, position, newName);
-  return convertLspWorkspaceEdit(edit);
+export async function runRenameRefactor(options: {
+  lsp: WorkspaceLspRuntime;
+  file: string;
+  position: CodePosition;
+  newName: string;
+  control?: CodeRequestControl;
+}): Promise<RefactorResult> {
+  const { lsp, file, position, newName, control } = options;
+  const response = control
+    ? await lsp.rename(file, position, newName, control)
+    : await lsp.rename(file, position, newName);
+  if (!response) {
+    return { kind: "unavailable", reason: "No routed LSP client could plan the rename." };
+  }
+  return normalizeSemanticEdit(
+    { kind: "workspace-edit", edit: response.value },
+    {
+      getOpenDocumentVersion: (candidate) => lsp.getOpenDocumentVersion(candidate),
+      authorizedMutationRoots: response.authorizedMutationRoots,
+    },
+  );
 }
 
-export function collectCodeActionResults(actions: CodeAction[]): RefactorResult[] {
+/**
+ * Normalize code-action edits. Without document state, versioned changes fail closed.
+ */
+export function collectCodeActionResults(
+  actions: CodeAction[],
+  context: SemanticEditNormalizationContext,
+): RefactorResult[] {
   const results: RefactorResult[] = [];
   for (const action of actions) {
-    if (!action.edit) {
-      results.push({
-        kind: "unavailable",
-        reason: `Code action "${action.title}" has no edit`,
-      });
-      continue;
-    }
-
-    const result = convertCodeActionToResult(action);
-    results.push(
-      result?.kind === "precise"
-        ? result
-        : {
-            kind: "unavailable",
-            reason: `Code action "${action.title}" could not produce precise edits`,
-          },
-    );
+    results.push(normalizeSemanticEdit({ kind: "code-action", action }, context));
   }
   return results;
 }
@@ -44,10 +55,14 @@ export async function runFilteredCodeActionRefactor(options: {
   operation: "update_imports" | "delete_dead_code" | "extract_function" | "extract_variable";
   range?: SourceRange;
   matches: (action: CodeAction) => boolean;
+  control?: CodeRequestControl;
 }): Promise<RefactorResult> {
   const { lsp, file, position, operation, matches } = options;
-  const actions = await lsp.codeActions(file, options.range ?? position);
-  if (!actions || actions.length === 0) {
+  const response = options.control
+    ? await lsp.codeActions(file, options.range ?? position, options.control)
+    : await lsp.codeActions(file, options.range ?? position);
+  const actions = response?.value;
+  if (!response || !actions || actions.length === 0) {
     return {
       kind: "unavailable",
       reason: `No code actions are available for refactor operation "${operation}".`,
@@ -62,16 +77,22 @@ export async function runFilteredCodeActionRefactor(options: {
     };
   }
 
+  const context: SemanticEditNormalizationContext = {
+    getOpenDocumentVersion: (candidate) => lsp.getOpenDocumentVersion(candidate),
+    authorizedMutationRoots: response.authorizedMutationRoots,
+  };
+  let unavailableReason: string | null = null;
   for (const action of matching) {
-    const converted = convertCodeActionToResult(action);
-    if (converted?.kind === "precise") {
-      return converted;
-    }
+    const converted = normalizeSemanticEdit({ kind: "code-action", action }, context);
+    if (converted.kind === "precise") return converted;
+    if (converted.kind === "unavailable") unavailableReason ??= converted.reason;
   }
 
   return {
     kind: "unavailable",
-    reason: `Matching code actions for refactor operation "${operation}" did not produce precise edits.`,
+    reason: unavailableReason
+      ? `Matching code action is unavailable: ${unavailableReason}`
+      : `Matching code actions for refactor operation "${operation}" did not produce precise edits.`,
   };
 }
 
@@ -120,87 +141,3 @@ export function isDeleteDeadCodeCodeAction(action: CodeAction): boolean {
     /(unused|dead code|remove unused|remove unreachable|remove declaration)/.test(title);
   return kindMatches && titleMatches;
 }
-
-function convertCodeActionToResult(action: CodeAction): RefactorResult | null {
-  if (!action.edit) {
-    return null;
-  }
-  return convertLspWorkspaceEdit(action.edit);
-}
-
-function convertLspWorkspaceEdit(edit: WorkspaceEdit | null): RefactorResult {
-  if (!edit) {
-    return { kind: "unavailable", reason: "LSP server returned no edit" };
-  }
-
-  let fileEdits = edit.documentChanges?.length
-    ? collectDocumentChangeEdits(edit.documentChanges)
-    : [];
-  if (fileEdits.length === 0 && edit.changes) {
-    fileEdits = collectChangesEdits(edit.changes);
-  }
-
-  if (fileEdits.length === 0) {
-    return { kind: "unavailable", reason: "Workspace edit contains no file edits" };
-  }
-
-  return { kind: "precise", edits: { edits: fileEdits } };
-}
-
-function collectDocumentChangeEdits(
-  docChanges: NonNullable<WorkspaceEdit["documentChanges"]>,
-): Array<{
-  file: string;
-  range: { start: { line: number; character: number }; end: { line: number; character: number } };
-  newText: string;
-}> {
-  const out: Array<{
-    file: string;
-    range: { start: { line: number; character: number }; end: { line: number; character: number } };
-    newText: string;
-  }> = [];
-  for (const change of docChanges) {
-    const tdEdit = change as TextDocumentEdit;
-    if (!tdEdit.textDocument || !tdEdit.edits) continue;
-    const file = uriToFile(tdEdit.textDocument.uri);
-    for (const singleEdit of tdEdit.edits) {
-      const te = singleEdit as TextEdit;
-      out.push({
-        file,
-        range: {
-          start: { line: te.range.start.line, character: te.range.start.character },
-          end: { line: te.range.end.line, character: te.range.end.character },
-        },
-        newText: te.newText,
-      });
-    }
-  }
-  return out;
-}
-
-function collectChangesEdits(changes: NonNullable<WorkspaceEdit["changes"]>): Array<{
-  file: string;
-  range: { start: { line: number; character: number }; end: { line: number; character: number } };
-  newText: string;
-}> {
-  const out: Array<{
-    file: string;
-    range: { start: { line: number; character: number }; end: { line: number; character: number } };
-    newText: string;
-  }> = [];
-  for (const [uri, textEdits] of Object.entries(changes)) {
-    if (!textEdits || textEdits.length === 0) continue;
-    const file = uriToFile(uri);
-    for (const te of textEdits) {
-      out.push({
-        file,
-        range: {
-          start: { line: te.range.start.line, character: te.range.start.character },
-          end: { line: te.range.end.line, character: te.range.end.character },
-        },
-        newText: te.newText,
-      });
-    }
-  }
-  return out;
-}

package/node_modules/@mrclrchtr/supi-lsp/src/provider/semantic-edit-normalizer.ts

@@ -0,0 +1,320 @@
+import { fileURLToPath } from "node:url";
+import type {
+  DocumentEditPrecondition,
+  FileEdit,
+  RefactorResult,
+} from "@mrclrchtr/supi-code-runtime/api";
+
+/** A complete semantic server response that can contain precise text edits. */
+export type SemanticEditResponse =
+  | { readonly kind: "workspace-edit"; readonly edit: unknown }
+  | { readonly kind: "code-action"; readonly action: unknown };
+
+/** Provider route and client document state used to establish mutation preconditions. */
+export interface SemanticEditNormalizationContext {
+  getOpenDocumentVersion(file: string): number | null;
+  authorizedMutationRoots: readonly string[];
+}
+
+/**
+ * Convert one complete semantic server response to a protocol-neutral edit plan.
+ * Reject the complete response when any part is not supported.
+ */
+export function normalizeSemanticEdit(
+  response: SemanticEditResponse,
+  context: SemanticEditNormalizationContext,
+): RefactorResult {
+  return response.kind === "code-action"
+    ? normalizeCodeAction(response.action, context)
+    : normalizeWorkspaceEdit(response.edit, context);
+}
+
+function normalizeCodeAction(
+  value: unknown,
+  context: SemanticEditNormalizationContext,
+): RefactorResult {
+  const action = asRecord(value);
+  if (
+    !action ||
+    typeof action.title !== "string" ||
+    !hasOnlyKeys(action, [
+      "title",
+      "kind",
+      "diagnostics",
+      "isPreferred",
+      "disabled",
+      "edit",
+      "command",
+      "data",
+    ])
+  ) {
+    return { kind: "unavailable", reason: "LSP server returned a malformed code action." };
+  }
+  const title = action.title;
+  if (Object.hasOwn(action, "disabled")) {
+    return { kind: "unavailable", reason: `Code action "${title}" is disabled.` };
+  }
+  if (Object.hasOwn(action, "command")) {
+    return {
+      kind: "unavailable",
+      reason: `Code action "${title}" requires a command and cannot become an edit-only precise plan.`,
+    };
+  }
+  if (!Object.hasOwn(action, "edit")) {
+    return { kind: "unavailable", reason: `Code action "${title}" has no edit` };
+  }
+  const result = normalizeWorkspaceEdit(action.edit, context);
+  return result.kind === "unavailable"
+    ? {
+        kind: "unavailable",
+        reason: `Code action "${title}" could not produce precise edits: ${result.reason}`,
+      }
+    : result;
+}
+
+function normalizeWorkspaceEdit(
+  value: unknown,
+  context: SemanticEditNormalizationContext,
+): RefactorResult {
+  if (value === null || value === undefined) {
+    return { kind: "unavailable", reason: "LSP server returned no edit." };
+  }
+  const workspaceEdit = asRecord(value);
+  if (
+    !workspaceEdit ||
+    !hasOnlyKeys(workspaceEdit, ["changes", "documentChanges", "changeAnnotations"])
+  ) {
+    return { kind: "unavailable", reason: "LSP server returned a malformed workspace edit." };
+  }
+  if (Object.hasOwn(workspaceEdit, "changeAnnotations")) {
+    return {
+      kind: "unavailable",
+      reason: "Workspace edit contains unsupported change annotations.",
+    };
+  }
+  return Object.hasOwn(workspaceEdit, "documentChanges")
+    ? normalizeDocumentChanges(workspaceEdit.documentChanges, context)
+    : normalizeChanges(workspaceEdit.changes, context);
+}
+
+function normalizeChanges(
+  value: unknown,
+  context: SemanticEditNormalizationContext,
+): RefactorResult {
+  const changes = asRecord(value);
+  if (!changes) {
+    return { kind: "unavailable", reason: "Workspace edit contains no supported changes." };
+  }
+
+  const edits: FileEdit[] = [];
+  for (const uri of Object.keys(changes).sort()) {
+    const file = toFilePath(uri);
+    const textEdits = changes[uri];
+    if (!file) {
+      return { kind: "unavailable", reason: `Workspace edit URI "${uri}" is not a file URI.` };
+    }
+    if (!Array.isArray(textEdits)) {
+      return { kind: "unavailable", reason: "Workspace edit contains malformed changes." };
+    }
+    const normalized = normalizeTextEdits(file, textEdits);
+    if (normalized.kind === "unavailable") return normalized;
+    edits.push(...normalized.edits);
+  }
+  return preciseOrEmpty(edits, context);
+}
+
+function normalizeDocumentChanges(
+  value: unknown,
+  context: SemanticEditNormalizationContext,
+): RefactorResult {
+  if (!Array.isArray(value)) {
+    return { kind: "unavailable", reason: "Workspace edit has malformed documentChanges." };
+  }
+
+  const edits: FileEdit[] = [];
+  const documentPreconditions: DocumentEditPrecondition[] = [];
+  for (const change of value) {
+    const normalized = normalizeDocumentChange(change, context);
+    if (normalized.kind === "unavailable") return normalized;
+    edits.push(...normalized.edits);
+    documentPreconditions.push(normalized.precondition);
+  }
+  return preciseOrEmpty(edits, context, documentPreconditions);
+}
+
+function normalizeDocumentChange(
+  value: unknown,
+  context: SemanticEditNormalizationContext,
+):
+  | { kind: "precise"; edits: FileEdit[]; precondition: DocumentEditPrecondition }
+  | { kind: "unavailable"; reason: string } {
+  const documentEdit = asRecord(value);
+  const resourceKind = getResourceOperationKind(documentEdit);
+  if (resourceKind) {
+    return {
+      kind: "unavailable",
+      reason: `Workspace edit contains the unsupported "${resourceKind}" resource operation.`,
+    };
+  }
+  const parsed = parseTextDocumentEdit(documentEdit);
+  if (!parsed) {
+    return { kind: "unavailable", reason: "Workspace edit has a malformed document change." };
+  }
+  const { edit, textDocument } = parsed;
+  const file = typeof textDocument.uri === "string" ? toFilePath(textDocument.uri) : null;
+  if (!file) {
+    return { kind: "unavailable", reason: "Document change does not contain a valid file URI." };
+  }
+  if (!("version" in textDocument)) {
+    return { kind: "unavailable", reason: "Document change does not contain a version." };
+  }
+  const precondition = establishPrecondition(file, textDocument.version, context);
+  if (typeof precondition === "string") {
+    return { kind: "unavailable", reason: precondition };
+  }
+  const normalized = normalizeTextEdits(file, edit.edits);
+  return normalized.kind === "unavailable"
+    ? normalized
+    : { kind: "precise", edits: normalized.edits, precondition };
+}
+
+function parseTextDocumentEdit(edit: Record<string, unknown> | null): {
+  edit: Record<"textDocument" | "edits", unknown> & { edits: unknown[] };
+  textDocument: Record<string, unknown>;
+} | null {
+  const textDocument = asRecord(edit?.textDocument);
+  if (
+    !edit ||
+    !hasOnlyKeys(edit, ["textDocument", "edits"]) ||
+    !textDocument ||
+    !hasOnlyKeys(textDocument, ["uri", "version"]) ||
+    !Array.isArray(edit.edits)
+  ) {
+    return null;
+  }
+  return {
+    edit: edit as Record<"textDocument" | "edits", unknown> & { edits: unknown[] },
+    textDocument,
+  };
+}
+
+function getResourceOperationKind(value: Record<string, unknown> | null): string | null {
+  return value && (value.kind === "create" || value.kind === "rename" || value.kind === "delete")
+    ? value.kind
+    : null;
+}
+
+function establishPrecondition(
+  file: string,
+  version: unknown,
+  context: SemanticEditNormalizationContext,
+): DocumentEditPrecondition | string {
+  const openVersion = context.getOpenDocumentVersion(file);
+  if (version === null) {
+    return openVersion === null
+      ? { file, kind: "disk-content" }
+      : `Document change for "${file}" requires disk content, but the document is open.`;
+  }
+  if (!Number.isInteger(version) || (version as number) < 0) {
+    return `Document change for "${file}" has an invalid version.`;
+  }
+  if (openVersion === null) {
+    return `Document change version for "${file}" cannot be established.`;
+  }
+  if (openVersion !== version) {
+    return `Document change version for "${file}" does not match the open document.`;
+  }
+  return { file, kind: "open-document-version", version: version as number };
+}
+
+function normalizeTextEdits(
+  file: string,
+  values: unknown[],
+): { kind: "precise"; edits: FileEdit[] } | { kind: "unavailable"; reason: string } {
+  const edits: FileEdit[] = [];
+  for (const value of values) {
+    const textEdit = asRecord(value);
+    if (textEdit && Object.hasOwn(textEdit, "snippet")) {
+      return { kind: "unavailable", reason: "Workspace edit contains a snippet text edit." };
+    }
+    if (textEdit && Object.hasOwn(textEdit, "annotationId")) {
+      return { kind: "unavailable", reason: "Workspace edit contains a text edit annotation." };
+    }
+    const range = asRecord(textEdit?.range);
+    const start = asPosition(range?.start);
+    const end = asPosition(range?.end);
+    if (
+      !textEdit ||
+      !hasOnlyKeys(textEdit, ["range", "newText"]) ||
+      !range ||
+      !hasOnlyKeys(range, ["start", "end"]) ||
+      !start ||
+      !end ||
+      isBefore(end, start) ||
+      typeof textEdit.newText !== "string"
+    ) {
+      return { kind: "unavailable", reason: "Workspace edit contains a malformed text edit." };
+    }
+    edits.push({ file, range: { start, end }, newText: textEdit.newText });
+  }
+  return { kind: "precise", edits };
+}
+
+function preciseOrEmpty(
+  edits: FileEdit[],
+  context: SemanticEditNormalizationContext,
+  documentPreconditions?: DocumentEditPrecondition[],
+): RefactorResult {
+  if (edits.length === 0) {
+    return { kind: "unavailable", reason: "Workspace edit contains no file edits." };
+  }
+  if (context.authorizedMutationRoots.length === 0) {
+    return {
+      kind: "unavailable",
+      reason: "Semantic route did not authorize a mutation root.",
+    };
+  }
+  const authorizedMutationRoots = [...context.authorizedMutationRoots];
+  return documentPreconditions
+    ? { kind: "precise", edits: { edits, documentPreconditions }, authorizedMutationRoots }
+    : { kind: "precise", edits: { edits }, authorizedMutationRoots };
+}
+
+function hasOnlyKeys(value: Record<string, unknown>, allowed: readonly string[]): boolean {
+  const allowedKeys = new Set(allowed);
+  return Object.keys(value).every((key) => allowedKeys.has(key));
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function asPosition(value: unknown): { line: number; character: number } | null {
+  const position = asRecord(value);
+  return position &&
+    hasOnlyKeys(position, ["line", "character"]) &&
+    Number.isInteger(position.line) &&
+    (position.line as number) >= 0 &&
+    Number.isInteger(position.character) &&
+    (position.character as number) >= 0
+    ? { line: position.line as number, character: position.character as number }
+    : null;
+}
+
+function isBefore(
+  left: { line: number; character: number },
+  right: { line: number; character: number },
+): boolean {
+  return left.line < right.line || (left.line === right.line && left.character < right.character);
+}
+
+function toFilePath(uri: string): string | null {
+  try {
+    const parsed = new URL(uri);
+    return parsed.protocol === "file:" ? fileURLToPath(parsed) : null;
+  } catch {
+    return null;
+  }
+}