@mrclrchtr/supi-lsp 11.4.0 → 12.0.0

package/src/client/client.ts

@@ -23,6 +23,7 @@ import { CodeActionTriggerKind } from "vscode-languageserver-types";
 import { CLIENT_CAPABILITIES } from "../config/capabilities.ts";
 import {
   getServerOperationSupport,
+  isCodeActionKindWithin,
   supportsCodeActionResolve,
   supportsCodeActions,
   supportsPrepareRename,
@@ -32,6 +33,7 @@ import {
 import type {
   CodeAction,
   CodeActionContext,
+  Command,
   Diagnostic,
   DidChangeWatchedFilesParams,
   DocumentDiagnosticReport,
@@ -71,6 +73,11 @@ import { createTypeScriptDiagnosticRequestAdapter } from "./client-diagnostic-ty
 import { ClientDiagnostics } from "./client-diagnostics.ts";
 import type { ClientDiagnosticSnapshot, DiagnosticEntry } from "./client-document-state.ts";
 import { type NormalizedDocumentSync, normalizeDocumentSync } from "./client-document-sync.ts";
+import {
+  type CommandEditCaptureResult,
+  EditCaptureWindow,
+  runCommandEditCapture,
+} from "./client-edit-capture.ts";
 import {
   SemanticInputRequestRetryGuard,
   type SemanticInputRequestRetryReason,
@@ -244,13 +251,6 @@ function isLazyCodeAction(value: unknown): value is CodeAction {
   );
 }
 
-function codeActionKindMatchesFilter(kind: unknown, filter: string): boolean {
-  return (
-    filter === "" ||
-    (typeof kind === "string" && (kind === filter || kind.startsWith(`${filter}.`)))
-  );
-}
-
 function isValidCommand(value: unknown): value is NonNullable<CodeAction["command"]> {
   const command = isRecord(value) ? value : null;
   return (
@@ -546,8 +546,11 @@ export class LspClient {
   private readonly settingsSnapshot: JsonObject | undefined;
   private readonly diagnosticRequestAdapter: DiagnosticRequestAdapter;
   private readonly diagnostics: ClientDiagnostics;
+  private readonly editCapture = new EditCaptureWindow();
   /** Dynamic capability registrations for this client instance only. */
   private readonly dynamicRegistrations = new ClientDynamicRegistrations();
+  /** Workspace association snapshot shared by `didOpen` and selector matching. */
+  private readonly fileAssociations: CFamilyFileAssociationResolver | undefined;
 
   // ── Readiness (work-done-progress) ──────────────────────────────────
   private trackedTokens = new Map<ProgressToken, "created" | "active" | "ended">();
@@ -576,6 +579,7 @@ export class LspClient {
   ) {
     this.name = name;
     this.root = root;
+    this.fileAssociations = fileAssociations;
     this.settingsSnapshot = cloneSettings(config.settings);
     const nativeDiagnosticAdapter: DiagnosticRequestAdapter = {
       supports: (uri) => this.hasApplicableDiagnosticProvider(uri),
@@ -1053,12 +1057,18 @@ export class LspClient {
     if (
       staticRecord !== undefined &&
       isValidDiagnosticOptions(staticRecord) &&
-      isDocumentSelectorApplicable(staticRecord.documentSelector, uri)
+      isDocumentSelectorApplicable(staticRecord.documentSelector, uri, this.fileAssociations)
     ) {
       return staticRecord;
     }
     for (const registration of this.dynamicRegistrations.get(DOCUMENT_DIAGNOSTIC_METHOD)) {
-      if (isDocumentSelectorApplicable(registration.options.documentSelector, uri)) {
+      if (
+        isDocumentSelectorApplicable(
+          registration.options.documentSelector,
+          uri,
+          this.fileAssociations,
+        )
+      ) {
         return registration.options;
       }
     }
@@ -1239,6 +1249,37 @@ export class LspClient {
     return result.kind === "completed" ? readTypeScriptProjectMembership(result.data) : "unknown";
   }
 
+  /**
+   * Run one server command and capture the single edit it pushes through
+   * `workspace/applyEdit`. Every pushed edit is refused, so no file changes.
+   * Open documents the edit touches are re-sent afterwards under new versions.
+   */
+  async captureCommandEdits(
+    command: Command,
+    options: {
+      timeoutMs: number;
+      graceMs?: number;
+      drainMs?: number;
+      control?: CodeRequestControl;
+    },
+  ): Promise<CommandEditCaptureResult> {
+    const rpc = this.rpc;
+    if (!rpc || this._status !== "running") {
+      return {
+        kind: "unavailable",
+        reason: "The server command is unavailable because the client is not running.",
+      };
+    }
+    return runCommandEditCapture({
+      command,
+      ...options,
+      window: this.editCapture,
+      sendRequestOwned: (method, params, requestOptions) =>
+        rpc.sendRequestOwned(method, params, requestOptions),
+      resynchronize: (file) => this.diagnostics.resynchronizeOpenDocument(file),
+    });
+  }
+
   async workspaceSymbol(
     query: string,
     control?: CodeRequestControl,
@@ -1430,7 +1471,17 @@ export class LspClient {
     control: CodeRequestControl | undefined,
     only: readonly string[] | undefined,
   ): Promise<CodeAction[]> {
-    const candidates = raw.map((value) => {
+    // Servers may still return kinds that `only` excludes (typescript-language-server
+    // adds quickfixes). Drop those before validation so they cannot fail the request.
+    const requested = only
+      ? raw.filter(
+          (value) =>
+            !isRecord(value) ||
+            typeof value.kind !== "string" ||
+            only.some((filter) => isCodeActionKindWithin(value.kind, filter)),
+        )
+      : raw;
+    const candidates = requested.map((value) => {
       const candidate = normalizeCodeActionResponseEntry(value);
       if (!candidate)
         throw new Error("LSP server returned a malformed code action response entry.");
@@ -1443,7 +1494,7 @@ export class LspClient {
         !this.supportsCodeActionResolve ||
         !lazyAction ||
         (only !== undefined &&
-          !only.some((filter) => codeActionKindMatchesFilter(lazyAction.kind, filter)))
+          !only.some((filter) => isCodeActionKindWithin(lazyAction.kind, filter)))
       ) {
         actions.push(action);
         continue;
@@ -1773,6 +1824,8 @@ export class LspClient {
 
   private handleServerRequest(method: string, params: unknown): unknown {
     switch (method) {
+      case "workspace/applyEdit":
+        return this.editCapture.handleApplyEdit(params);
       case "workspace/configuration":
         return this.buildWorkspaceConfigurationResult(params);
       case "workspace/workspaceFolders":

package/src/config/capabilities.ts

@@ -42,15 +42,20 @@ export const CLIENT_CAPABILITIES: ClientCapabilities = {
             "refactor.extract.constant",
             "refactor.extract.variable",
             "refactor.inline",
+            "refactor.move",
             "refactor.rewrite",
             "source",
             "source.organizeImports",
             "source.fixAll",
             "source.removeUnused",
+            "source.removeUnusedImports",
+            "source.sortImports",
           ],
         },
       },
       dataSupport: true,
+      // Never advertise `workspace.workspaceEdit.snippetEditSupport` (LSP 3.18):
+      // snippet edits cannot become exact previewable text plans.
       // SuPi resolves only the edit property. Commands and other fields
       // must remain server-owned and are never advertised as resolvable.
       resolveSupport: { properties: ["edit"] },
@@ -72,6 +77,9 @@ export const CLIENT_CAPABILITIES: ClientCapabilities = {
     workDoneProgress: true,
   },
   workspace: {
+    // Servers may push edits through workspace/applyEdit. SuPi records them
+    // only while previewing one command and always replies applied: false.
+    applyEdit: true,
     configuration: true,
     workspaceFolders: true,
     workspaceEdit: {

package/src/config/operation-support.ts

@@ -4,10 +4,8 @@ import type { ServerCapabilities } from "vscode-languageserver-protocol";
 export type ServerOperationName =
   | "rename_symbol"
   | "prepare_rename"
-  | "extract_function"
-  | "extract_variable"
-  | "update_imports"
-  | "delete_dead_code"
+  | "code_action"
+  | "source_action"
   | "code_action_resolve";
 
 /** Whether a server advertises one operation in its negotiated capabilities. */
@@ -19,6 +17,13 @@ export interface ServerOperationSupport {
   readonly supi: "supported" | "limited" | "unsupported";
   /** A stable explanation for a SuPi planning limitation or deferral. */
   readonly reason?: string;
+  /** Advertised CodeActionKinds in this operation's family (`refactor*` or `source*`). */
+  readonly kinds?: readonly string[];
+  /**
+   * The server may return kinds beyond `kinds`: it advertises CodeActionKind.Empty
+   * (`""`) or does not narrow `codeActionKinds` at all.
+   */
+  readonly anyKind?: boolean;
 }
 
 /** Operation support projected onto a project-server health entry. */
@@ -26,23 +31,6 @@ export type ServerOperationSupportMap = Partial<
   Record<ServerOperationName, ServerOperationSupport>
 >;
 
-const REMOVE_UNUSED_KIND = "source.removeUnused";
-const REMOVE_UNUSED_IMPORTS_KIND = "source.removeUnusedImports";
-
-/** Code-action kinds requested by each operation-specific planner. */
-export const REFACTOR_CODE_ACTION_KINDS = {
-  extract_function: ["refactor.extract.function"],
-  extract_variable: ["refactor.extract.constant", "refactor.extract.variable"],
-  update_imports: ["source.organizeImports"],
-  delete_dead_code: [REMOVE_UNUSED_KIND, REMOVE_UNUSED_IMPORTS_KIND],
-} as const satisfies Record<
-  "extract_function" | "extract_variable" | "update_imports" | "delete_dead_code",
-  readonly string[]
->;
-
-const EXTRACTION_NAME_LIMITATION =
-  "Standard LSP code actions do not provide a safe exact extraction-name contract.";
-
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -95,6 +83,22 @@ export function supportsCodeActionResolve(capabilities: ServerCapabilities | nul
   return codeActionOptions(capabilities)?.resolveProvider === true;
 }
 
+/**
+ * Test whether a returned CodeActionKind falls under a requested kind: the same
+ * kind or a dotted descendant. The empty kind requests every kind.
+ */
+export function isCodeActionKindWithin(kind: unknown, requested: string): boolean {
+  if (requested === "") return true;
+  return typeof kind === "string" && (kind === requested || kind.startsWith(`${requested}.`));
+}
+
+/** Return the negotiated `codeActionKinds`, or undefined when the server did not narrow them. */
+export function advertisedCodeActionKinds(
+  capabilities: ServerCapabilities | null,
+): readonly string[] | undefined {
+  return codeActionOptions(capabilities)?.kinds;
+}
+
 /** Test the documented hierarchical relationship between two code-action kinds. */
 export function isCodeActionKindInRange(kind: string, requested: string): boolean {
   if (kind === "" || requested === "") return true;
@@ -118,46 +122,30 @@ export function supportsRequestedCodeActionKinds(
   );
 }
 
-function codeActionAdvertisement(
-  capabilities: ServerCapabilities | null,
-  requested: readonly string[],
-): ServerAdvertisement {
-  if (capabilities === null) return "unknown";
-  const options = codeActionOptions(capabilities);
-  if (!options) return "not-advertised";
-  if (requested.length === 0 || !options.kinds) return "unknown";
-  if (!supportsRequestedCodeActionKinds(capabilities, requested)) return "not-advertised";
-
-  // A generic parent or the empty kind proves eligibility, but it does not
-  // prove that this exact operation is implemented by the server.
-  const exactOrChild = requested.some((wanted) =>
-    options.kinds?.some(
-      (kind) => kind === wanted || (wanted !== "" && kind.startsWith(`${wanted}.`)),
-    ),
-  );
-  return exactOrChild ? "advertised" : "unknown";
+function supportedOperation(server: ServerAdvertisement): ServerOperationSupport {
+  return { server, supi: "supported" };
 }
 
-function supportedOperation(
-  server: ServerAdvertisement,
-  supi: ServerOperationSupport["supi"] = "supported",
-  reason?: string,
+/** Project advertised kinds for one CodeActionKind family, such as `refactor` or `source`. */
+function codeActionFamilySupport(
+  capabilities: ServerCapabilities | null,
+  family: "refactor" | "source",
 ): ServerOperationSupport {
-  return { server, supi, ...(reason ? { reason } : {}) };
-}
-
-function deleteDeadCodeSupport(capabilities: ServerCapabilities | null): ServerOperationSupport {
-  const server = codeActionAdvertisement(capabilities, REFACTOR_CODE_ACTION_KINDS.delete_dead_code);
-  const importsOnly =
-    codeActionAdvertisement(capabilities, [REMOVE_UNUSED_KIND]) !== "advertised" &&
-    codeActionAdvertisement(capabilities, [REMOVE_UNUSED_IMPORTS_KIND]) === "advertised";
-  return importsOnly
-    ? supportedOperation(
-        server,
-        "limited",
-        "Only unused-import removal is supported by this mapping, not arbitrary unused declarations.",
-      )
-    : supportedOperation(server);
+  if (capabilities === null) return supportedOperation("unknown");
+  const options = codeActionOptions(capabilities);
+  if (!options) return supportedOperation("not-advertised");
+  // An unnarrowed provider or the empty kind may return kinds it does not list.
+  const anyKind = !options.kinds || options.kinds.includes("");
+  const kinds = (options.kinds ?? []).filter(
+    (kind) => kind !== "" && isCodeActionKindWithin(kind, family),
+  );
+  if (kinds.length === 0 && !anyKind) return supportedOperation("not-advertised");
+  return {
+    server: "advertised",
+    supi: "supported",
+    ...(kinds.length > 0 ? { kinds } : {}),
+    ...(anyKind ? { anyKind } : {}),
+  };
 }
 
 /** Build the honest operation-support projection for one negotiated server. */
@@ -185,27 +173,8 @@ export function getServerOperationSupport(
   return {
     rename_symbol: supportedOperation(renameServer),
     prepare_rename: supportedOperation(prepareServer),
-    extract_function: supportedOperation(
-      codeActionAdvertisement(capabilities, REFACTOR_CODE_ACTION_KINDS.extract_function),
-      "limited",
-      EXTRACTION_NAME_LIMITATION,
-    ),
-    extract_variable: supportedOperation(
-      codeActionAdvertisement(capabilities, REFACTOR_CODE_ACTION_KINDS.extract_variable),
-      "limited",
-      EXTRACTION_NAME_LIMITATION,
-    ),
-    update_imports: supportedOperation(
-      codeActionAdvertisement(capabilities, REFACTOR_CODE_ACTION_KINDS.update_imports),
-    ),
-    delete_dead_code: deleteDeadCodeSupport(capabilities),
+    code_action: codeActionFamilySupport(capabilities, "refactor"),
+    source_action: codeActionFamilySupport(capabilities, "source"),
     code_action_resolve: supportedOperation(resolveServer),
   };
 }
-
-/** Get the exact operation-specific kinds used in a code-action request. */
-export function codeActionKindsForOperation(
-  operation: keyof typeof REFACTOR_CODE_ACTION_KINDS,
-): readonly string[] {
-  return REFACTOR_CODE_ACTION_KINDS[operation];
-}

package/src/manager/manager.ts

@@ -1107,7 +1107,9 @@ export class LspManager {
     if (client.status !== "running" || !client.ready) return;
     const key = clientKey(client.name, client.root);
     const recovery = this.processCrashRecoveries.get(key);
-    if (recovery) {
+    // An in-flight recovery owns its record until it settles; removing it here
+    // would make that recovery report cancellation for a live replacement.
+    if (recovery && !recovery.pending) {
       recovery.attemptConsumed = false;
       recovery.statusReason = undefined;
       recovery.failureMessage = undefined;

package/src/provider/lsp-refactor-provider.ts

@@ -7,10 +7,10 @@ import type {
 import type { WorkspaceLspRuntime } from "../session/runtime-registry.ts";
 import {
   collectCodeActionResults,
-  isDeleteDeadCodeCodeAction,
-  isUpdateImportsCodeAction,
-  runFilteredCodeActionRefactor,
+  runCodeActionRefactor,
   runRenameRefactor,
+  runSourceActionRefactor,
+  wholeDocumentRange,
 } from "./refactor-planning.ts";
 
 /** Build optional refactor methods for the semantic provider adapter. */
@@ -45,12 +45,6 @@ async function planRefactor(
 ): Promise<RefactorResult> {
   switch (request.operation) {
     case "rename_symbol":
-      if (!request.newName) {
-        return {
-          kind: "unavailable",
-          reason: 'Refactor operation "rename_symbol" requires `newName`.',
-        };
-      }
       return runRenameRefactor({
         lsp,
         file: request.file,
@@ -58,39 +52,31 @@ async function planRefactor(
         newName: request.newName,
         control,
       });
-    case "extract_function":
-    case "extract_variable":
-      return {
-        kind: "unavailable",
-        reason: `Refactor operation "${request.operation}" is unavailable: standard LSP code actions do not provide a safe exact extraction-name contract.`,
-      };
-    case "update_imports":
-      return runFilteredCodeActionRefactor({
+    case "code_action":
+      return runCodeActionRefactor({
         lsp,
         file: request.file,
-        position: request.position,
-        operation: "update_imports",
-        matches: isUpdateImportsCodeAction,
+        range: request.range,
+        kind: request.kind,
+        title: request.title,
+        label: "Code action",
         control,
       });
-    case "delete_dead_code":
-      return runFilteredCodeActionRefactor({
+    case "source_action": {
+      // LSP source actions apply to the entire file, so request the whole document.
+      const range = wholeDocumentRange(request.file);
+      if (!range) {
+        return { kind: "unavailable", reason: `File ${request.file} could not be read.` };
+      }
+      return runSourceActionRefactor({
         lsp,
         file: request.file,
-        position: request.position,
-        operation: "delete_dead_code",
-        matches: isDeleteDeadCodeCodeAction,
+        range,
+        kind: request.kind,
+        title: request.title,
+        label: "Source action",
         control,
       });
-    case "rename_file":
-    case "move_file":
-      return {
-        kind: "unavailable",
-        reason: `Refactor operation "${request.operation}" is not supported yet. File/resource operations are deferred.`,
-      };
+    }
   }
-  return {
-    kind: "unavailable",
-    reason: `Refactor operation "${request.operation}" is not supported by the active semantic provider.`,
-  };
 }

package/src/provider/refactor-command-capture.ts

@@ -0,0 +1,139 @@
+/**
+ * Plan command-only code actions by capturing the edit their command pushes.
+ *
+ * Only `refactor*`, `source.organizeImports*`, and `source.fixAll*` commands
+ * may run, and only when the server lists the command (if it lists any). Other
+ * source commands can have side effects outside the editor, so they never run.
+ * Several eligible actions stay ambiguous without running any command.
+ */
+
+import type {
+  CodeRequestControl,
+  DisambiguationCandidate,
+  DocumentEditPrecondition,
+  RefactorResult,
+} from "@mrclrchtr/supi-code-runtime/api";
+import { isCodeActionKindWithin } from "../config/operation-support.ts";
+import type { CodeAction, Command } from "../config/types.ts";
+import type { WorkspaceLspRuntime } from "../session/workspace-lsp-runtime.ts";
+import { normalizeSemanticEdit } from "./semantic-edit-normalizer.ts";
+
+const CAPTURE_ELIGIBLE_KINDS = ["refactor", "source.organizeImports", "source.fixAll"] as const;
+
+/**
+ * Stable reason for command-only actions SuPi will not run: an ineligible kind
+ * or a command the server does not list.
+ */
+export const COMMAND_ONLY_ACTION_REASON =
+  "Matching code actions only run a server command that SuPi does not run for preview.";
+
+/** A code action whose only effect is a server command. */
+export type CommandOnlyAction = CodeAction & { command: Command; kind: string };
+
+/** Whether a code action has a command and no edit. */
+export function isCommandOnlyAction(action: CodeAction): boolean {
+  return Object.hasOwn(action, "command") && !action.edit;
+}
+
+/**
+ * Select the command-only actions SuPi may run to capture an edit: an eligible
+ * kind, and a command the server lists when it lists any.
+ */
+export function captureEligibleActions(
+  actions: readonly CodeAction[],
+  advertisedCommands: readonly string[] | undefined,
+): CommandOnlyAction[] {
+  return actions.filter((action): action is CommandOnlyAction => {
+    const command = action.command;
+    return (
+      isCommandOnlyAction(action) &&
+      typeof action.kind === "string" &&
+      typeof command?.command === "string" &&
+      CAPTURE_ELIGIBLE_KINDS.some((kind) => isCodeActionKindWithin(action.kind, kind)) &&
+      (advertisedCommands === undefined || advertisedCommands.includes(command.command))
+    );
+  });
+}
+
+/** Candidates for several eligible command-only actions; no command has run. */
+export function commandCandidates(actions: readonly CommandOnlyAction[]): RefactorResult {
+  return {
+    kind: "ambiguous",
+    candidates: actions.map(
+      (action): DisambiguationCandidate => ({
+        description: action.title,
+        kind: action.kind,
+        title: action.title,
+      }),
+    ),
+  };
+}
+
+/**
+ * Run one action's command, capture its single pushed edit, and normalize it
+ * like a direct edit. Versioned preconditions move to the resynced versions,
+ * which hold the same content.
+ */
+export async function captureCommandAction(options: {
+  lsp: WorkspaceLspRuntime;
+  file: string;
+  action: CommandOnlyAction;
+  control?: CodeRequestControl;
+}): Promise<RefactorResult> {
+  const { lsp, file, action, control } = options;
+  const response = await lsp.captureCodeActionEdit(file, action, control);
+  if (!response) {
+    return { kind: "unavailable", reason: "No routed LSP client could run the command." };
+  }
+  const roots = [...response.authorizedMutationRoots];
+  const capture = response.value;
+  if (!capture || capture.kind === "unavailable") {
+    return {
+      kind: "unavailable",
+      reason: `Command for "${action.title}" is unavailable: ${capture?.reason ?? response.reason ?? "no result."}`,
+      authorizedMutationRoots: roots,
+    };
+  }
+
+  const before = new Map(capture.resynced.map((entry) => [entry.file, entry]));
+  const result = normalizeSemanticEdit(
+    { kind: "workspace-edit", edit: capture.edit },
+    {
+      // Captured edits target the versions from before the resync.
+      getOpenDocumentVersion: (candidate) => {
+        const current = lsp.getOpenDocumentVersion(candidate);
+        const versions = before.get(candidate);
+        return versions && current === versions.to ? versions.from : current;
+      },
+      authorizedMutationRoots: response.authorizedMutationRoots,
+    },
+  );
+  if (result.kind !== "precise") {
+    return result.kind === "unavailable"
+      ? {
+          kind: "unavailable",
+          reason: `Captured edit for "${action.title}" could not produce precise edits: ${result.reason}`,
+          authorizedMutationRoots: roots,
+        }
+      : result;
+  }
+  const preconditions = result.edits.documentPreconditions?.map((precondition) =>
+    rebase(precondition, before),
+  );
+  return {
+    ...result,
+    edits: { ...result.edits, ...(preconditions ? { documentPreconditions: preconditions } : {}) },
+    action: { kind: action.kind, title: action.title, provenance: "captured-command" },
+  };
+}
+
+function rebase(
+  precondition: DocumentEditPrecondition,
+  resynced: ReadonlyMap<string, { from: number; to: number }>,
+): DocumentEditPrecondition {
+  if (precondition.kind === "disk-content") return precondition;
+  const versions = resynced.get(precondition.file);
+  return versions && precondition.version === versions.from
+    ? { ...precondition, version: versions.to }
+    : precondition;
+}