@mrclrchtr/supi-lsp 11.3.0 → 12.0.0

package/src/manager/manager-typescript-coverage.ts

@@ -0,0 +1,118 @@
+import * as path from "node:path";
+import { collectExtendedProjectConfigs } from "../config/tsconfig-extends.ts";
+import { normalizeTsconfigPath } from "../config/tsconfig-path.ts";
+import { getFileScopeDecision, projectConfigIncludesFile } from "../config/tsconfig-scope.ts";
+import { type AutomaticLspPathPolicy, walkAutomaticLspTree } from "../workspace-path-policy.ts";
+
+/** Directory depth searched for project configs below a TypeScript route root. */
+const PROJECT_CONFIG_SCAN_DEPTH = 8;
+/** Project config paths named in one coverage reason. */
+const MAX_NAMED_PROJECTS = 3;
+/** File names tsserver loads as projects; `tsconfig.*.json` variants are never auto-loaded. */
+const LOADABLE_PROJECT_CONFIGS = new Set(["tsconfig.json", "jsconfig.json"]);
+
+/** Find loadable project configs under a route root, honoring the automatic path policy. */
+export function discoverTypeScriptProjectConfigs(
+  root: string,
+  policy: AutomaticLspPathPolicy,
+): string[] {
+  const configs: string[] = [];
+  walkAutomaticLspTree(policy, root, PROJECT_CONFIG_SCAN_DEPTH, (directory, entries) => {
+    for (const entry of entries) {
+      if (entry.isFile() && LOADABLE_PROJECT_CONFIGS.has(entry.name)) {
+        configs.push(path.join(directory, entry.name));
+      }
+    }
+    return false;
+  });
+  return configs;
+}
+
+/**
+ * Project configs whose program includes `file` but show no sign of being loaded.
+ *
+ * tsserver answers project-wide requests such as references and
+ * implementations only from loaded projects, and loads a project only when one
+ * of its files is open. An unloaded including project (typically a test
+ * config that includes `../src`) can hold matches the answer omits.
+ *
+ * A project counts as loaded when it is the nearest config of an open file or
+ * of a file in the answer (`resultFiles`): tsserver also loads projects on its
+ * own during a search, and a match from a project's own file proves it was searched.
+ *
+ * Base configs extended by another discovered config are skipped: their
+ * default include usually spans the whole tree while they own only root
+ * tooling files, so counting them would mark nearly every answer partial.
+ */
+export function findUnloadedTypeScriptProjects(options: {
+  readonly file: string;
+  readonly cwd: string;
+  readonly openFiles: readonly string[];
+  readonly resultFiles?: readonly string[];
+  readonly configs: readonly string[];
+}): string[] {
+  const baseConfigs = new Set(
+    options.configs.flatMap((config) => [...collectExtendedProjectConfigs(config)]),
+  );
+  const loaded = new Set<string>();
+  for (const loadedFile of [...options.openFiles, ...(options.resultFiles ?? [])]) {
+    const decision = getFileScopeDecision(loadedFile, options.cwd);
+    if (decision.status === "included" && decision.configPath) {
+      loaded.add(normalizeTsconfigPath(decision.configPath));
+    }
+  }
+  return options.configs.filter((config) => {
+    const key = normalizeTsconfigPath(config);
+    return (
+      !loaded.has(key) && !baseConfigs.has(key) && projectConfigIncludesFile(config, options.file)
+    );
+  });
+}
+
+/**
+ * Other projects that tsserver's implementation search skips for `file`.
+ *
+ * tsserver 6 and earlier answer `textDocument/implementation` from the file's
+ * default project only, unlike references, which span loaded projects. Any
+ * other non-base project may implement the target through an import, and
+ * opening its files does not change the answer.
+ */
+export function findSkippedImplementationProjects(options: {
+  readonly file: string;
+  readonly cwd: string;
+  readonly configs: readonly string[];
+}): string[] {
+  const baseConfigs = new Set(
+    options.configs.flatMap((config) => [...collectExtendedProjectConfigs(config)]),
+  );
+  const decision = getFileScopeDecision(options.file, options.cwd);
+  const own = decision.configPath ? normalizeTsconfigPath(decision.configPath) : undefined;
+  return options.configs.filter((config) => {
+    const key = normalizeTsconfigPath(config);
+    return key !== own && !baseConfigs.has(key);
+  });
+}
+
+/** Partial-result reason for tsserver's single-project implementation search. */
+export function singleProjectImplementationReason(skipped: readonly string[]): string {
+  const noun = skipped.length === 1 ? "1 other project is" : `${skipped.length} other projects are`;
+  return (
+    "TypeScript coverage is limited: the TypeScript 6 or earlier server (tsserver) " +
+    `searches implementations only in this file's project; ${noun} not searched. ` +
+    "Use references to find uses in other projects, or use TypeScript 7."
+  );
+}
+
+/** Actionable partial-result reason naming a bounded set of unloaded projects. */
+export function typeScriptCoverageGapReason(unloaded: readonly string[], cwd: string): string {
+  const named = unloaded
+    .slice(0, MAX_NAMED_PROJECTS)
+    .map((config) => path.relative(cwd, config) || path.basename(config));
+  const more = unloaded.length > named.length ? `, +${unloaded.length - named.length} more` : "";
+  const noun = unloaded.length === 1 ? "project that includes" : "projects that include";
+  return (
+    `TypeScript coverage is limited: ${unloaded.length} ${noun} this file ` +
+    `${unloaded.length === 1 ? "is" : "are"} not loaded (${named.join(", ")}${more}). ` +
+    "Open a file from each project and retry."
+  );
+}

package/src/manager/manager.ts

@@ -128,6 +128,13 @@ import type {
   OutstandingDiagnosticSummaryEntry,
   ServerStatus,
 } from "./manager-types.ts";
+import {
+  discoverTypeScriptProjectConfigs,
+  findSkippedImplementationProjects,
+  findUnloadedTypeScriptProjects,
+  singleProjectImplementationReason,
+  typeScriptCoverageGapReason,
+} from "./manager-typescript-coverage.ts";
 import {
   recoverWorkspaceDiagnostics as recoverWorkspaceDiagnosticsImpl,
   type WorkspaceRecoveryResult,
@@ -141,6 +148,7 @@ import {
   workspaceSymbolCollectionResult,
   workspaceSymbolCoverageGap,
 } from "./manager-workspace-symbol.ts";
+import { isFileLocalTopLevelDeclaration } from "./typescript-file-local.ts";
 
 type UnavailableReason = "missing-command" | "start-failed" | "runtime-error";
 
@@ -412,6 +420,8 @@ export class LspManager {
   private warmedSemanticProjects = new Set<string>();
   /** In-flight warm-up probes keyed by project key so concurrent callers share one probe. */
   private pendingWarmProbes = new Map<string, Promise<void>>();
+  /** Loadable TypeScript project configs per route root; cleared when a config changes. */
+  private typeScriptProjectConfigs = new Map<string, string[]>();
   /** One process-crash recovery budget and shared replacement per route. */
   private processCrashRecoveries = new Map<string, ProcessCrashRecoveryState>();
   /** Client generations that completed the initialize handshake. */
@@ -572,6 +582,53 @@ export class LspManager {
     );
   }
 
+  /**
+   * Coverage gap for a project-wide TypeScript request answered by `client`.
+   *
+   * Returns a partial-result reason when a TypeScript project that includes
+   * `filePath` owns neither an open file nor a file in `resultFiles`, so
+   * tsserver may not have searched it; otherwise null. Non-TypeScript routes
+   * always return null.
+   *
+   * Implementation requests not known to use the native backend report every
+   * other project instead: tsserver searches only the file's own project.
+   *
+   * No gap applies when `position` (zero-based) names a top-level declaration
+   * its module does not export: no other project can reference it.
+   */
+  typeScriptProjectCoverageGap(
+    client: LspClient,
+    filePath: string,
+    request: "references" | "implementation",
+    evidence: {
+      readonly resultFiles?: readonly string[];
+      readonly position?: { readonly line: number; readonly character: number };
+    } = {},
+  ): string | null {
+    const { resultFiles = [], position } = evidence;
+    if (client.name !== "typescript") return null;
+    const rootKey = path.resolve(client.root);
+    let configs = this.typeScriptProjectConfigs.get(rootKey);
+    if (!configs) {
+      configs = discoverTypeScriptProjectConfigs(rootKey, this.automaticPathPolicy);
+      this.typeScriptProjectConfigs.set(rootKey, configs);
+    }
+    const file = resolveSessionPath(this.cwd, filePath);
+    if (position && isFileLocalTopLevelDeclaration(file, position)) return null;
+    if (request === "implementation" && client.typescriptSelection?.backend !== "native") {
+      const skipped = findSkippedImplementationProjects({ file, cwd: this.cwd, configs });
+      return skipped.length > 0 ? singleProjectImplementationReason(skipped) : null;
+    }
+    const unloaded = findUnloadedTypeScriptProjects({
+      file,
+      cwd: this.cwd,
+      openFiles: client.openFiles,
+      resultFiles,
+      configs,
+    });
+    return unloaded.length > 0 ? typeScriptCoverageGapReason(unloaded, this.cwd) : null;
+  }
+
   /** Get or create an LSP client for the given file. */
   async getClientForFile(
     filePath: string,
@@ -1050,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;
@@ -2397,7 +2456,7 @@ export class LspManager {
    */
   noteWorkspaceChanges(changes: FileEvent[]): void {
     if (changes.length > 0) this.invalidationEpoch++;
-    invalidateProjectConfigCaches(changes);
+    if (invalidateProjectConfigCaches(changes)) this.typeScriptProjectConfigs.clear();
     this.notifyWorkspaceFileChanges(changes);
   }
 
@@ -2586,6 +2645,7 @@ export class LspManager {
     this.warmedWorkspaceSymbolFiles.clear();
     this.warmedSemanticProjects.clear();
     this.pendingWarmProbes.clear();
+    this.typeScriptProjectConfigs.clear();
     this.pendingRestarts.clear();
   }
   /** Get status of all servers. */
@@ -3437,15 +3497,19 @@ export class LspManager {
   }
 }
 
-function invalidateProjectConfigCaches(changes: readonly FileEvent[]): void {
+/** Invalidate parsed project configs; returns whether any config changed. */
+function invalidateProjectConfigCaches(changes: readonly FileEvent[]): boolean {
+  let changed = false;
   for (const change of changes) {
     const configPath = uriToFile(change.uri);
     if (!isProjectConfigFileName(path.basename(configPath))) continue;
+    changed = true;
     invalidateTsconfigCacheForConfig(configPath);
     if (change.type === FileChangeType.Created) {
       invalidateTsconfigCacheForConfigDir(path.dirname(configPath));
     }
   }
+  return changed;
 }
 
 function collectClientDiagnosticEvidenceDocuments(

package/src/manager/typescript-file-local.ts

@@ -0,0 +1,87 @@
+import * as fs from "node:fs";
+import ts from "typescript";
+
+/**
+ * Whether the identifier at `position` names a top-level declaration that only
+ * its own file can reference: the file is an ES module and the declaration is
+ * neither exported by a modifier nor by an export clause or assignment.
+ *
+ * Other TypeScript projects can then hold no references or implementations,
+ * so a project coverage gap cannot apply. Script files (no import or export),
+ * members, unreadable files, and non-declaration positions return false.
+ *
+ * @param position Zero-based LSP position.
+ */
+export function isFileLocalTopLevelDeclaration(
+  filePath: string,
+  position: { readonly line: number; readonly character: number },
+): boolean {
+  let text: string;
+  try {
+    text = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return false;
+  }
+  const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true);
+  if (!ts.isExternalModule(sourceFile)) return false;
+  let offset: number;
+  try {
+    offset = ts.getPositionOfLineAndCharacter(sourceFile, position.line, position.character);
+  } catch {
+    return false;
+  }
+  const statement = sourceFile.statements.find(
+    (candidate) => candidate.getStart(sourceFile) <= offset && offset < candidate.end,
+  );
+  if (!statement) return false;
+  const name = topLevelDeclarationNameAt(statement, offset, sourceFile);
+  return name !== null && !hasExportModifier(statement) && !exportedByName(sourceFile, name);
+}
+
+/** Name of the declaration `statement` declares at `offset`, or null. */
+function topLevelDeclarationNameAt(
+  statement: ts.Statement,
+  offset: number,
+  sourceFile: ts.SourceFile,
+): string | null {
+  const names: ts.Identifier[] = [];
+  if (
+    ts.isFunctionDeclaration(statement) ||
+    ts.isClassDeclaration(statement) ||
+    ts.isInterfaceDeclaration(statement) ||
+    ts.isTypeAliasDeclaration(statement) ||
+    ts.isEnumDeclaration(statement)
+  ) {
+    if (statement.name) names.push(statement.name);
+  } else if (ts.isVariableStatement(statement)) {
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts.isIdentifier(declaration.name)) names.push(declaration.name);
+    }
+  }
+  const hit = names.find((name) => name.getStart(sourceFile) <= offset && offset <= name.end);
+  return hit ? hit.text : null;
+}
+
+function hasExportModifier(statement: ts.Statement): boolean {
+  return (
+    ts.canHaveModifiers(statement) &&
+    (ts.getModifiers(statement) ?? []).some(
+      (modifier) =>
+        modifier.kind === ts.SyntaxKind.ExportKeyword ||
+        modifier.kind === ts.SyntaxKind.DeclareKeyword,
+    )
+  );
+}
+
+/** `export { name }`, `export default name`, or `export = name` in this file. */
+function exportedByName(sourceFile: ts.SourceFile, name: string): boolean {
+  return sourceFile.statements.some((statement) => {
+    if (ts.isExportAssignment(statement)) {
+      return ts.isIdentifier(statement.expression) && statement.expression.text === name;
+    }
+    if (!ts.isExportDeclaration(statement) || statement.moduleSpecifier) return false;
+    const clause = statement.exportClause;
+    if (!clause || !ts.isNamedExports(clause)) return false;
+    return clause.elements.some((element) => (element.propertyName ?? element.name).text === name);
+  });
+}

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;
+}