@mrclrchtr/supi-lsp 11.3.0 → 12.0.0

package/src/client/client-edit-capture.ts

@@ -0,0 +1,258 @@
+/**
+ * Capture window for server-pushed `workspace/applyEdit` requests.
+ *
+ * SuPi never applies an edit that a server pushes. While one command runs for
+ * preview, each pushed edit is recorded and refused; outside that window every
+ * pushed edit is refused as unsolicited (LSP 3.17 `ApplyWorkspaceEditResult`).
+ */
+
+import {
+  type CodeRequestControl,
+  isCodeRequestInterruption,
+} from "@mrclrchtr/supi-code-runtime/api";
+import { uriToFile } from "@mrclrchtr/supi-core/path";
+import type { Command, WorkspaceEdit } from "../config/types.ts";
+import { LSP_REQUEST_TIMEOUT_ERROR_CODE } from "../debug-telemetry.ts";
+import { JsonRpcRequestError } from "./transport.ts";
+
+/** Reply for an edit recorded for preview. */
+export const CAPTURED_EDIT_REPLY = {
+  applied: false,
+  failureReason: "SuPi captured this edit for preview.",
+} as const;
+
+/** Reply for an edit that arrives outside a capture window. */
+export const UNSOLICITED_EDIT_REPLY = {
+  applied: false,
+  failureReason: "SuPi does not accept unsolicited workspace edits.",
+} as const;
+
+/** Result of running one command inside a capture window. */
+export type CommandEditCaptureResult =
+  | {
+      readonly kind: "captured";
+      /** The single edit the server pushed while the command ran. */
+      readonly edit: WorkspaceEdit;
+      /** Open documents re-sent afterwards, with their versions before and after. */
+      readonly resynced: readonly { file: string; from: number; to: number }[];
+    }
+  | { readonly kind: "unavailable"; readonly reason: string };
+
+/** Reply for an edit from a command SuPi stopped waiting for. */
+export const ABANDONED_EDIT_REPLY = {
+  applied: false,
+  failureReason: "SuPi stopped waiting for the command that produced this edit.",
+} as const;
+
+/**
+ * Records pushed edits for at most one capture per client. After a capture
+ * stops waiting (timeout, abort, deadline) the window keeps draining until the
+ * abandoned command settles, so its late edits are refused and can never be
+ * attributed to the next capture.
+ */
+export class EditCaptureWindow {
+  #state: "idle" | "capturing" | "draining" = "idle";
+  #edits: unknown[] = [];
+  #onEdit: (() => void) | undefined;
+
+  /** Open the window. Returns false while another capture runs or drains. */
+  open(): boolean {
+    if (this.#state !== "idle") return false;
+    this.#state = "capturing";
+    this.#edits = [];
+    return true;
+  }
+
+  /** Stop capturing and return the edits pushed so far. */
+  close(): unknown[] {
+    const edits = this.#edits;
+    this.#edits = [];
+    this.#onEdit = undefined;
+    if (this.#state === "capturing") this.#state = "idle";
+    return edits;
+  }
+
+  /** Stop capturing but refuse new captures until `settled` resolves. */
+  drain(settled: Promise<void>): unknown[] {
+    const edits = this.close();
+    this.#state = "draining";
+    void settled.then(() => {
+      if (this.#state === "draining") this.#state = "idle";
+    });
+    return edits;
+  }
+
+  /** Wait up to `ms` for the first edit when none has arrived yet. */
+  async waitForEdit(ms: number): Promise<void> {
+    if (this.#edits.length > 0 || ms <= 0) return;
+    await new Promise<void>((resolve) => {
+      const timer = setTimeout(resolve, ms);
+      this.#onEdit = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+    });
+  }
+
+  /** Answer one `workspace/applyEdit` request; the edit is never applied. */
+  handleApplyEdit(
+    params: unknown,
+  ): typeof CAPTURED_EDIT_REPLY | typeof UNSOLICITED_EDIT_REPLY | typeof ABANDONED_EDIT_REPLY {
+    if (this.#state === "draining") return ABANDONED_EDIT_REPLY;
+    if (this.#state === "idle") return UNSOLICITED_EDIT_REPLY;
+    const edit =
+      typeof params === "object" && params !== null
+        ? (params as { edit?: unknown }).edit
+        : undefined;
+    this.#edits.push(edit);
+    this.#onEdit?.();
+    return CAPTURED_EDIT_REPLY;
+  }
+}
+
+/** Collect the file URIs a captured edit touches, for resynchronization. */
+export function editedDocumentUris(edit: unknown): string[] {
+  if (typeof edit !== "object" || edit === null) return [];
+  const uris = new Set<string>();
+  const { changes, documentChanges } = edit as {
+    changes?: unknown;
+    documentChanges?: unknown;
+  };
+  if (typeof changes === "object" && changes !== null) {
+    for (const uri of Object.keys(changes)) uris.add(uri);
+  }
+  if (Array.isArray(documentChanges)) {
+    for (const change of documentChanges) {
+      const uri = (change as { textDocument?: { uri?: unknown } } | null)?.textDocument?.uri;
+      if (typeof uri === "string") uris.add(uri);
+    }
+  }
+  return [...uris];
+}
+
+/** Default wait for an edit a server pushes just after answering the command. */
+const DEFAULT_GRACE_MS = 250;
+
+/** Collaborators for one command capture on one client. */
+export interface CommandEditCaptureOptions {
+  readonly command: Command;
+  /** Upper bound for the command to finish. */
+  readonly timeoutMs: number;
+  /** Wait for an edit pushed after the command answers; LSP allows that order. */
+  readonly graceMs?: number;
+  /** Upper bound for refusing late edits from an abandoned command. */
+  readonly drainMs?: number;
+  readonly control?: CodeRequestControl;
+  readonly window: EditCaptureWindow;
+  /** Send one request and expose when its transport lifetime ends. */
+  sendRequestOwned(
+    method: string,
+    params: unknown,
+    options: { timeoutMs: number } & CodeRequestControl,
+  ): { result: Promise<unknown>; settled: Promise<void> };
+  /** Re-send one open document; null when it is not open. */
+  resynchronize(file: string): { from: number; to: number } | null;
+}
+
+/**
+ * Run one command inside a capture window. Exactly one pushed edit becomes the
+ * result; none, several, a timeout, or a server error are unavailable.
+ * Cancellation and deadline expiry propagate. Every touched open document is
+ * resynced, and an abandoned command keeps the window draining.
+ */
+export async function runCommandEditCapture(
+  options: CommandEditCaptureOptions,
+): Promise<CommandEditCaptureResult> {
+  const { command, timeoutMs, control, window } = options;
+  if (!window.open()) {
+    return {
+      kind: "unavailable",
+      reason: "Another server command capture is running on this client; retry shortly.",
+    };
+  }
+  const request = options.sendRequestOwned(
+    "workspace/executeCommand",
+    { command: command.command, ...(command.arguments ? { arguments: command.arguments } : {}) },
+    { ...control, timeoutMs },
+  );
+  let serverError: string | undefined;
+  try {
+    await request.result;
+  } catch (error) {
+    if (!(error instanceof JsonRpcRequestError) || isCodeRequestInterruption(error, control)) {
+      return abandonCapture(options, request.settled, error);
+    }
+    // The server answered with an error, so the command is over. clangd
+    // reports that the refused edit "was not applied"; the edit still counts.
+    serverError = error.message;
+  }
+  if (serverError === undefined) await window.waitForEdit(options.graceMs ?? DEFAULT_GRACE_MS);
+  const edits = window.close();
+  const resynced = resynchronizeEdits(edits, options.resynchronize);
+  if (edits.length === 0) {
+    return {
+      kind: "unavailable",
+      reason:
+        serverError === undefined
+          ? "The server command produced no edit; there may be nothing to change."
+          : `The server command failed: ${serverError}`,
+    };
+  }
+  if (edits.length > 1) {
+    return {
+      kind: "unavailable",
+      reason: `The server command produced ${edits.length} edits; only one can be previewed.`,
+    };
+  }
+  return { kind: "captured", edit: edits[0] as WorkspaceEdit, resynced };
+}
+
+/** Close or drain the window after SuPi stopped waiting for the command, then report or rethrow. */
+function abandonCapture(
+  options: CommandEditCaptureOptions,
+  settled: Promise<void>,
+  error: unknown,
+): CommandEditCaptureResult {
+  const { window, timeoutMs, control } = options;
+  const drainMs = options.drainMs ?? timeoutMs;
+  const edits = drainMs > 0 ? window.drain(boundedSettle(settled, drainMs)) : window.close();
+  resynchronizeEdits(edits, options.resynchronize);
+  if (isCodeRequestInterruption(error, control)) throw error;
+  return {
+    kind: "unavailable",
+    reason: isTimeout(error)
+      ? `The server command did not finish within ${timeoutMs} ms.`
+      : `The server command could not run: ${error instanceof Error ? error.message : String(error)}`,
+  };
+}
+
+function boundedSettle(settled: Promise<void>, ms: number): Promise<void> {
+  return Promise.race([settled, new Promise<void>((resolve) => setTimeout(resolve, ms))]);
+}
+
+function resynchronizeEdits(
+  edits: readonly unknown[],
+  resynchronize: CommandEditCaptureOptions["resynchronize"],
+): { file: string; from: number; to: number }[] {
+  const uris = new Set(edits.flatMap((edit) => editedDocumentUris(edit)));
+  const resynced: { file: string; from: number; to: number }[] = [];
+  for (const uri of uris) {
+    let file: string;
+    try {
+      file = uriToFile(uri);
+    } catch {
+      continue;
+    }
+    const versions = resynchronize(file);
+    if (versions) resynced.push({ file, ...versions });
+  }
+  return resynced;
+}
+
+function isTimeout(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    (error as { code?: unknown }).code === LSP_REQUEST_TIMEOUT_ERROR_CODE
+  );
+}

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/config/tsconfig-scope.ts

@@ -162,6 +162,16 @@ export function getFileScopeDecision(filePath: string, cwd: string): FileScopeDe
   };
 }
 
+/**
+ * Whether a project config's program includes a file, by its own file set or
+ * include/exclude rules. Unlike {@link getFileScopeDecision}, the config need
+ * not be the file's nearest one (e.g. a test config including `../src`).
+ */
+export function projectConfigIncludesFile(configPath: string, filePath: string): boolean {
+  const parsed = parseProjectConfig(configPath);
+  return parsed !== null && decideFileScope(parsed, path.resolve(filePath)).included;
+}
+
 function isOutOfTree(cwd: string, absolutePath: string): boolean {
   const relative = path.relative(path.resolve(cwd), absolutePath);
   return relative.startsWith(`..${path.sep}`) || relative === "..";