@mrclrchtr/supi-lsp 7.4.0 → 8.0.1

package/src/config/capabilities.ts

@@ -38,14 +38,22 @@ export const CLIENT_CAPABILITIES: ClientCapabilities = {
             "quickfix",
             "refactor",
             "refactor.extract",
+            "refactor.extract.function",
+            "refactor.extract.constant",
+            "refactor.extract.variable",
             "refactor.inline",
             "refactor.rewrite",
             "source",
             "source.organizeImports",
             "source.fixAll",
+            "source.removeUnused",
           ],
         },
       },
+      dataSupport: true,
+      // SuPi resolves only the edit property. Commands and other fields
+      // must remain server-owned and are never advertised as resolvable.
+      resolveSupport: { properties: ["edit"] },
     },
     publishDiagnostics: {
       relatedInformation: true,
@@ -64,6 +72,7 @@ export const CLIENT_CAPABILITIES: ClientCapabilities = {
     workDoneProgress: true,
   },
   workspace: {
+    configuration: true,
     workspaceFolders: true,
     workspaceEdit: {
       documentChanges: true,

package/src/config/config.ts

@@ -3,9 +3,9 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { loadSupiConfigForScope } from "@mrclrchtr/supi-core/config";
+import { loadSupiConfigForScope, loadSupiConfigSectionForScope } from "@mrclrchtr/supi-core/config";
 import { truncateDebugIdentity } from "@mrclrchtr/supi-core/debug";
-import type { LspConfig, ServerConfig } from "./types.ts";
+import type { JsonObject, JsonValue, LspConfig, ServerConfig } from "./types.ts";
 
 const CONFIG_DIR = path.dirname(fileURLToPath(import.meta.url));
 
@@ -18,6 +18,8 @@ const DEFAULTS: LspConfig = JSON.parse(
 
 export interface LoadConfigOptions {
   homeDir?: string;
+  /** Whether project-scoped server configuration is trusted. Defaults to true. */
+  projectTrusted?: boolean;
 }
 
 /** Map from language alias → canonical config key. */
@@ -25,6 +27,7 @@ export const LANGUAGE_ALIASES: Record<string, string> = {
   cpp: "c",
 };
 
+/** Alias fields override canonical fields, independent of property order. */
 function resolveAliasesInOverrides(servers: Record<string, unknown>): void {
   for (const [alias, target] of Object.entries(LANGUAGE_ALIASES)) {
     if (!Object.hasOwn(servers, alias)) continue;
@@ -52,18 +55,60 @@ export function loadConfig(cwd: string, options?: LoadConfigOptions): LspConfig
     { servers: {} as Record<string, ServerConfig> },
     { scope: "global", homeDir: options?.homeDir },
   );
-  const projectLsp = loadSupiConfigForScope(
-    "lsp",
-    cwd,
-    { servers: {} as Record<string, ServerConfig> },
-    { scope: "project" },
-  );
+  const projectLsp =
+    options?.projectTrusted === false
+      ? { servers: {} as Record<string, ServerConfig> }
+      : loadSupiConfigForScope(
+          "lsp",
+          cwd,
+          { servers: {} as Record<string, ServerConfig> },
+          { scope: "project" },
+        );
 
   const merged = mergeServerConfigs(defaults.servers, globalLsp.servers, projectLsp.servers);
 
   return { servers: merged };
 }
 
+/**
+ * Read effective explicit language disablement for the active LSP snapshot.
+ * Project values override global values, including an explicit re-enable.
+ */
+export function getExplicitlyDisabledLanguages(cwd: string, options?: LoadConfigOptions): string[] {
+  const effective = new Map<string, boolean>();
+  applyEnabledOverrides(
+    effective,
+    loadSupiConfigSectionForScope("lsp", cwd, {
+      scope: "global",
+      homeDir: options?.homeDir,
+    }),
+  );
+  if (options?.projectTrusted !== false) {
+    applyEnabledOverrides(
+      effective,
+      loadSupiConfigSectionForScope("lsp", cwd, { scope: "project" }),
+    );
+  }
+  return [...effective]
+    .filter(([, enabled]) => enabled === false)
+    .map(([name]) => name)
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function applyEnabledOverrides(
+  effective: Map<string, boolean>,
+  section: Record<string, unknown> | null,
+): void {
+  const servers = section?.servers;
+  if (!isRecord(servers)) return;
+  const normalized = { ...servers };
+  resolveAliasesInOverrides(normalized);
+  for (const [name, value] of Object.entries(normalized)) {
+    if (!isRecord(value) || typeof value.enabled !== "boolean") continue;
+    effective.set(name, value.enabled);
+  }
+}
+
 /**
  * Find which server config handles a given file extension.
  * Returns [languageName, config] or null.
@@ -217,6 +262,11 @@ const SERVER_OVERRIDE_SETTERS: Record<string, ServerOverrideSetter> = {
     override.env = candidate;
     return true;
   },
+  settings(override, candidate) {
+    if (!isJsonObject(candidate)) return false;
+    override.settings = candidate;
+    return true;
+  },
   initializationOptions(override, candidate) {
     override.initializationOptions = candidate;
     return true;
@@ -262,6 +312,17 @@ function isStringRecord(value: unknown): value is Record<string, string> {
   return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
 
+function isJsonObject(value: unknown): value is JsonObject {
+  return isJsonValue(value) && isRecord(value);
+}
+
+function isJsonValue(value: unknown): value is JsonValue {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every((entry) => isJsonValue(entry));
+  return isRecord(value) && Object.values(value).every((entry) => isJsonValue(entry));
+}
+
 function warnInvalidServerConfig(name: string, fields: readonly string[], skipped: boolean): void {
   const boundedName = truncateDebugIdentity(name);
   const boundedFields = truncateDebugIdentity(fields.join(", "));

package/src/config/operation-support.ts

@@ -0,0 +1,196 @@
+import type { ServerCapabilities } from "vscode-languageserver-protocol";
+
+/** Refactor operations that the public LSP runtime can report. */
+export type ServerOperationName =
+  | "rename_symbol"
+  | "prepare_rename"
+  | "extract_function"
+  | "extract_variable"
+  | "update_imports"
+  | "delete_dead_code"
+  | "code_action_resolve";
+
+/** Whether a server advertises one operation in its negotiated capabilities. */
+export type ServerAdvertisement = "advertised" | "not-advertised" | "unknown";
+
+/** SuPi support and server advertisement for one operation. */
+export interface ServerOperationSupport {
+  readonly server: ServerAdvertisement;
+  readonly supi: "supported" | "limited" | "unsupported";
+  /** A stable explanation for a SuPi planning limitation or deferral. */
+  readonly reason?: string;
+}
+
+/** Operation support projected onto a project-server health entry. */
+export type ServerOperationSupportMap = Partial<
+  Record<ServerOperationName, ServerOperationSupport>
+>;
+
+/** 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: ["source.removeUnused"],
+} 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);
+}
+
+function codeActionOptions(capabilities: ServerCapabilities | null): {
+  kinds?: readonly string[];
+  resolveProvider?: boolean;
+} | null {
+  const provider = capabilities?.codeActionProvider;
+  if (provider === true) return {};
+  if (!isRecord(provider)) return null;
+  return {
+    ...(Array.isArray(provider.codeActionKinds)
+      ? {
+          kinds: provider.codeActionKinds.filter(
+            (kind): kind is string => typeof kind === "string",
+          ),
+        }
+      : {}),
+    ...(provider.resolveProvider === true ? { resolveProvider: true } : {}),
+  };
+}
+
+function renameProvider(
+  capabilities: ServerCapabilities | null,
+): Record<string, unknown> | true | null {
+  const provider = capabilities?.renameProvider;
+  if (provider === true) return true;
+  return isRecord(provider) ? provider : null;
+}
+
+/** Return true when a server advertises rename requests. */
+export function supportsRename(capabilities: ServerCapabilities | null): boolean {
+  return renameProvider(capabilities) !== null;
+}
+
+/** Return true when a server advertises `prepareRename`. */
+export function supportsPrepareRename(capabilities: ServerCapabilities | null): boolean {
+  const provider = renameProvider(capabilities);
+  return isRecord(provider) && provider.prepareProvider === true;
+}
+
+/** Return true when a server advertises code actions. */
+export function supportsCodeActions(capabilities: ServerCapabilities | null): boolean {
+  return codeActionOptions(capabilities) !== null;
+}
+
+/** Return true when a server advertises code-action resolution. */
+export function supportsCodeActionResolve(capabilities: ServerCapabilities | null): boolean {
+  return codeActionOptions(capabilities)?.resolveProvider === true;
+}
+
+/** Test the documented hierarchical relationship between two code-action kinds. */
+export function isCodeActionKindInRange(kind: string, requested: string): boolean {
+  if (kind === "" || requested === "") return true;
+  return kind === requested || kind.startsWith(`${requested}.`) || requested.startsWith(`${kind}.`);
+}
+
+/**
+ * Check whether a requested kind can be supplied by a server's advertised
+ * code-action kinds. An absent kind list means the server did not narrow its
+ * provider, so the request remains eligible.
+ */
+export function supportsRequestedCodeActionKinds(
+  capabilities: ServerCapabilities | null,
+  requested: readonly string[],
+): boolean {
+  const options = codeActionOptions(capabilities);
+  if (!options || requested.length === 0 || !options.kinds) return options !== null;
+  if (options.kinds.length === 0) return false;
+  return requested.some((wanted) =>
+    options.kinds?.some((kind) => isCodeActionKindInRange(kind, wanted)),
+  );
+}
+
+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,
+  supi: ServerOperationSupport["supi"] = "supported",
+  reason?: string,
+): ServerOperationSupport {
+  return { server, supi, ...(reason ? { reason } : {}) };
+}
+
+/** Build the honest operation-support projection for one negotiated server. */
+export function getServerOperationSupport(
+  capabilities: ServerCapabilities | null,
+): ServerOperationSupportMap {
+  const renameServer =
+    capabilities === null
+      ? "unknown"
+      : supportsRename(capabilities)
+        ? "advertised"
+        : "not-advertised";
+  const prepareServer =
+    capabilities === null
+      ? "unknown"
+      : supportsPrepareRename(capabilities)
+        ? "advertised"
+        : "not-advertised";
+  const resolveServer =
+    capabilities === null
+      ? "unknown"
+      : supportsCodeActionResolve(capabilities)
+        ? "advertised"
+        : "not-advertised";
+  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: supportedOperation(
+      codeActionAdvertisement(capabilities, REFACTOR_CODE_ACTION_KINDS.delete_dead_code),
+    ),
+    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/config/server-config.ts

@@ -1,6 +1,16 @@
 // SuPi-specific server configuration types — not part of the LSP specification.
+
+import type { ServerOperationSupportMap } from "./operation-support.ts";
 // These are our own types for server discovery, configuration, and status tracking.
 
+/** JSON values accepted by a server's advanced settings object. */
+export type JsonValue = string | number | boolean | null | JsonValue[] | JsonObject;
+
+/** A JSON object passed to a language server as advanced settings. */
+export interface JsonObject {
+  readonly [key: string]: JsonValue;
+}
+
 export interface ServerConfig {
   command: string;
   args?: string[];
@@ -10,6 +20,9 @@ export interface ServerConfig {
   enabled?: boolean;
   /** Environment values added when the server process starts. */
   env?: Record<string, string>;
+  /** Server-owned configuration settings. This object replaces inherited settings as a whole. */
+  settings?: JsonObject;
+  /** Options sent during initialize; kept separate from `settings`. */
   initializationOptions?: unknown;
   /** Maximum time to wait for a single $/progress cycle, in ms. Default: 10_000. */
   readinessTimeoutMs?: number;
@@ -39,6 +52,8 @@ export interface ProjectServerInfo extends DetectedProjectServer {
   openFiles: string[];
   /** Whether the LSP server is currently not indexing and ready to serve queries. */
   ready: boolean;
+  /** Negotiated operation support, when the route has a capability snapshot. */
+  operationSupport?: ServerOperationSupportMap;
 }
 
 /** A language whose source files are present but the server binary is missing. */

package/src/config/types.ts

@@ -24,6 +24,7 @@ export {
   AnnotatedTextEdit,
   CodeAction,
   type CodeActionContext,
+  CodeActionTriggerKind,
   Command,
   Diagnostic,
   DiagnosticRelatedInformation,
@@ -48,10 +49,17 @@ export {
   WorkspaceEdit,
   WorkspaceSymbol,
 } from "vscode-languageserver-types";
-
+export type {
+  ServerAdvertisement,
+  ServerOperationName,
+  ServerOperationSupport,
+  ServerOperationSupportMap,
+} from "./operation-support.ts";
 // ── SuPi-specific server config ──────────────────────────────────────
 export type {
   DetectedProjectServer,
+  JsonObject,
+  JsonValue,
   LspConfig,
   MissingServer,
   ProjectServerInfo,

package/src/manager/manager-project-info.ts

@@ -1,4 +1,5 @@
 import type { LspClient } from "../client/client.ts";
+import { getServerOperationSupport } from "../config/operation-support.ts";
 import type { ProjectServerInfo, ProjectServerStatusReason } from "../config/server-config.ts";
 import { displayRelativeFilePath } from "../summary.ts";
 
@@ -38,5 +39,6 @@ export function buildProjectServerInfo(
         .filter((file) => input.includeOpenFile?.(file) ?? true)
         .map((file) => displayRelativeFilePath(file, cwd)) ?? [],
     ready: input.client?.ready ?? false,
+    operationSupport: getServerOperationSupport(input.client?.serverCapabilities ?? null),
   };
 }

package/src/manager/manager-workspace-symbol.ts

@@ -55,6 +55,10 @@ export interface WorkspaceSymbolCollection {
   hasSupport: boolean;
   completedClientCount: number;
   failures: string[];
+  /** Results removed by the automatic path policy. */
+  excludedCount?: number;
+  /** Bounded paths removed by the automatic path policy. */
+  excludedExamples?: string[];
 }
 
 export async function collectWorkspaceSymbols(
@@ -84,6 +88,16 @@ export async function collectWorkspaceSymbols(
   return { results, hasSupport, completedClientCount, failures };
 }
 
+function workspaceSymbolExclusionReason(collection: WorkspaceSymbolCollection): string | null {
+  const excludedCount = collection.excludedCount ?? 0;
+  if (excludedCount === 0) return null;
+  const noun = `workspace-symbol result${excludedCount === 1 ? "" : "s"}`;
+  const examples = collection.excludedExamples?.length
+    ? ` Examples: ${collection.excludedExamples.join(", ")}.`
+    : "";
+  return `Automatic path policy excluded ${excludedCount} ${noun}.${examples}`;
+}
+
 /** Project one multi-client collection into the shared typed query contract. */
 export function workspaceSymbolCollectionResult(
   collection: WorkspaceSymbolCollection,
@@ -96,8 +110,23 @@ export function workspaceSymbolCollectionResult(
       collection.failures.join("; ") || "No workspace-symbol request completed.",
     );
   }
-  if (collection.failures.length > 0) {
-    return partialCodeQuery(collection.results, collection.failures.join("; "));
+  const exclusion = workspaceSymbolExclusionReason(collection);
+  if (collection.failures.length > 0 || exclusion) {
+    const excludedCount = collection.excludedCount ?? 0;
+    const metadata =
+      excludedCount > 0
+        ? {
+            automaticPathExclusion: {
+              excludedCount,
+              examples: [...(collection.excludedExamples ?? [])],
+            },
+          }
+        : undefined;
+    return partialCodeQuery(
+      collection.results,
+      [collection.failures.join("; "), exclusion].filter(Boolean).join("; "),
+      metadata,
+    );
   }
   return completedCodeQuery(collection.results);
 }

package/src/manager/manager.ts

@@ -1938,6 +1938,10 @@ export class LspManager {
         { policy: this.automaticPathPolicy },
       )[0];
       if (target) await this.warmSemanticProject(firstReady, target.file, false, control);
+      // The warm-up request can start server indexing after the initial
+      // readiness wait resolves. Observe the resulting progress before
+      // reporting the workspace as ready.
+      await firstReady.getReady(control);
     }
 
     throwIfCodeRequestInterrupted(control);
@@ -2126,6 +2130,23 @@ export class LspManager {
     this.notifyWorkspaceFileChanges(changes);
   }
 
+  /** Synchronize tracked files after successful writes and send requested saves. */
+  noteWorkspaceWrites(changes: FileEvent[]): void {
+    if (changes.length === 0) return;
+    this.noteWorkspaceChanges(changes);
+
+    const writtenFiles = [
+      ...new Set(
+        changes
+          .filter((change) => change.type === FileChangeType.Changed)
+          .map((change) => uriToFile(change.uri)),
+      ),
+    ];
+    for (const client of this.clients.values()) {
+      for (const filePath of writtenFiles) client.noteWorkspaceWrite(filePath);
+    }
+  }
+
   /** Return per-route diagnostic evidence capability for recovery targeting. */
   getClientDiagnosticRoutes(): Array<{
     key: string;
@@ -2630,8 +2651,8 @@ export class LspManager {
           : null,
       control,
     );
-    const collect = async (clients: Iterable<LspClient>, value: string) =>
-      this.addWorkspaceSymbolDemandEvidence(
+    const collect = async (clients: Iterable<LspClient>, value: string) => {
+      const collection = this.addWorkspaceSymbolDemandEvidence(
         await collectWorkspaceSymbols(
           Array.from(clients).filter((client) => routeMatches(client)),
           value,
@@ -2639,6 +2660,8 @@ export class LspManager {
         ),
         demand,
       );
+      return this.filterWorkspaceSymbolCollection(collection, resolvedScopes);
+    };
     const initial = await collect(this.clients.values(), query);
     if (!initial.hasSupport || initial.results.length > 0) {
       return workspaceSymbolCollectionResult(initial);
@@ -2669,6 +2692,53 @@ export class LspManager {
     };
   }
 
+  private filterWorkspaceSymbolCollection(
+    collection: WorkspaceSymbolCollection,
+    scopes: readonly string[] | undefined,
+  ): WorkspaceSymbolCollection {
+    const excludedExamples: string[] = [];
+    let excludedCount = 0;
+    const results = collection.results.filter((result) => {
+      const file = uriToFile(result.location.uri);
+      if (this.isWorkspaceSymbolResultAllowed(file, scopes)) return true;
+      excludedCount++;
+      if (excludedExamples.length < 5) {
+        excludedExamples.push(displayRelativeFilePath(file, this.cwd));
+      }
+      return false;
+    });
+    return {
+      ...collection,
+      results,
+      excludedCount: (collection.excludedCount ?? 0) + excludedCount,
+      excludedExamples: [...(collection.excludedExamples ?? []), ...excludedExamples].slice(0, 5),
+    };
+  }
+
+  /** Keep explicitly selected excluded scopes inspectable while filtering broad results. */
+  private isWorkspaceSymbolResultAllowed(
+    filePath: string,
+    scopes: readonly string[] | undefined,
+  ): boolean {
+    if (this.automaticPathPolicy.isEligible(filePath, "file")) return true;
+    if (!scopes || scopes.length === 0) return false;
+
+    const resolvedFile = path.resolve(filePath);
+    return scopes.some((scope) => {
+      const resolvedScope = path.resolve(scope);
+      if (resolvedScope === resolvedFile) return true;
+      try {
+        if (!fs.statSync(resolvedScope).isDirectory()) return false;
+      } catch {
+        return false;
+      }
+      return (
+        !this.automaticPathPolicy.isEligible(resolvedScope, "directory") &&
+        projectRoots.isWithinOrEqual(resolvedScope, resolvedFile)
+      );
+    });
+  }
+
   private hasWorkspaceSymbolRouteForScopes(scopes: readonly string[]): boolean {
     const clients = [
       ...this.clients.values(),

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

@@ -4,13 +4,10 @@ import type {
   RefactorResult,
   SemanticProvider,
 } from "@mrclrchtr/supi-code-runtime/api";
-import type { CodeAction } from "../config/types.ts";
 import type { WorkspaceLspRuntime } from "../session/runtime-registry.ts";
 import {
   collectCodeActionResults,
   isDeleteDeadCodeCodeAction,
-  isExtractFunctionCodeAction,
-  isExtractVariableCodeAction,
   isUpdateImportsCodeAction,
   runFilteredCodeActionRefactor,
   runRenameRefactor,
@@ -28,7 +25,11 @@ export function createLspRefactorProvider(
       const response = control
         ? await lsp.codeActions(file, position, control)
         : await lsp.codeActions(file, position);
-      if (!response?.value) return [];
+      if (!response) return [];
+      if (response.reason && !response.value) {
+        return [{ kind: "unavailable", reason: response.reason }];
+      }
+      if (!response.value) return [];
       return collectCodeActionResults(response.value, {
         getOpenDocumentVersion: (candidate) => lsp.getOpenDocumentVersion(candidate),
         authorizedMutationRoots: response.authorizedMutationRoots,
@@ -58,21 +59,11 @@ async function planRefactor(
         control,
       });
     case "extract_function":
-      return runExtractRefactor({
-        lsp,
-        request,
-        operation: "extract_function",
-        matches: isExtractFunctionCodeAction,
-        control,
-      });
     case "extract_variable":
-      return runExtractRefactor({
-        lsp,
-        request,
-        operation: "extract_variable",
-        matches: isExtractVariableCodeAction,
-        control,
-      });
+      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({
         lsp,
@@ -103,28 +94,3 @@ async function planRefactor(
     reason: `Refactor operation "${request.operation}" is not supported by the active semantic provider.`,
   };
 }
-
-function runExtractRefactor(options: {
-  lsp: WorkspaceLspRuntime;
-  request: RefactorRequest;
-  operation: "extract_function" | "extract_variable";
-  matches: (action: CodeAction) => boolean;
-  control?: CodeRequestControl;
-}): Promise<RefactorResult> | RefactorResult {
-  const { lsp, request, operation, matches, control } = options;
-  if (!request.range) {
-    return {
-      kind: "unavailable",
-      reason: `Refactor operation "${operation}" requires \`range\`.`,
-    };
-  }
-  return runFilteredCodeActionRefactor({
-    lsp,
-    file: request.file,
-    position: request.position,
-    range: request.range,
-    operation,
-    matches,
-    control,
-  });
-}