@mrclrchtr/supi-lsp 1.16.1 → 2.0.0

package/src/provider/refactor-planning.ts

@@ -0,0 +1,214 @@
+import type { CodePosition, RefactorResult, SourceRange } from "@mrclrchtr/supi-code-runtime/api";
+import type { CodeAction, TextDocumentEdit, TextEdit, WorkspaceEdit } from "../config/types.ts";
+import type { SessionLspService } from "../session/service-registry.ts";
+
+export async function runRenameRefactor(
+  lsp: SessionLspService,
+  file: string,
+  position: CodePosition,
+  newName: string,
+): Promise<RefactorResult> {
+  const edit = await lsp.rename(file, position, newName);
+  return convertLspWorkspaceEdit(edit);
+}
+
+export function collectCodeActionResults(actions: CodeAction[]): RefactorResult[] {
+  const results: RefactorResult[] = [];
+  for (const action of actions) {
+    if (!action.edit) {
+      results.push({
+        kind: "unavailable",
+        reason: `Code action "${action.title}" has no edit`,
+      });
+      continue;
+    }
+
+    const result = convertCodeActionToResult(action);
+    results.push(
+      result?.kind === "precise"
+        ? result
+        : {
+            kind: "unavailable",
+            reason: `Code action "${action.title}" could not produce precise edits`,
+          },
+    );
+  }
+  return results;
+}
+
+export async function runFilteredCodeActionRefactor(options: {
+  lsp: SessionLspService;
+  file: string;
+  position: CodePosition;
+  operation: "update_imports" | "delete_dead_code" | "extract_function" | "extract_variable";
+  range?: SourceRange;
+  matches: (action: CodeAction) => boolean;
+}): Promise<RefactorResult> {
+  const { lsp, file, position, operation, matches } = options;
+  const actions = await lsp.codeActions(file, options.range ?? position);
+  if (!actions || actions.length === 0) {
+    return {
+      kind: "unavailable",
+      reason: `No code actions are available for refactor operation "${operation}".`,
+    };
+  }
+
+  const matching = actions.filter(matches);
+  if (matching.length === 0) {
+    return {
+      kind: "unavailable",
+      reason: `No matching precise code action is available for refactor operation "${operation}".`,
+    };
+  }
+
+  for (const action of matching) {
+    const converted = convertCodeActionToResult(action);
+    if (converted?.kind === "precise") {
+      return converted;
+    }
+  }
+
+  return {
+    kind: "unavailable",
+    reason: `Matching code actions for refactor operation "${operation}" did not produce precise edits.`,
+  };
+}
+
+export function isUpdateImportsCodeAction(action: CodeAction): boolean {
+  const kind = action.kind ?? "";
+  const title = action.title.trim().toLowerCase();
+  const kindlessTitleMatch = kind === "" && title === "organize imports";
+  return (
+    kind === "source.organizeImports" ||
+    kind.startsWith("source.organizeImports.") ||
+    kindlessTitleMatch
+  );
+}
+
+export function isExtractFunctionCodeAction(action: CodeAction): boolean {
+  const kind = action.kind ?? "";
+  const title = action.title.trim().toLowerCase();
+  return (
+    kind === "refactor.extract.function" ||
+    kind.startsWith("refactor.extract.function.") ||
+    (title.includes("extract") && /\b(function|method)\b/.test(title))
+  );
+}
+
+export function isExtractVariableCodeAction(action: CodeAction): boolean {
+  const kind = action.kind ?? "";
+  const title = action.title.trim().toLowerCase();
+  return (
+    kind === "refactor.extract.constant" ||
+    kind.startsWith("refactor.extract.constant.") ||
+    kind === "refactor.extract.variable" ||
+    kind.startsWith("refactor.extract.variable.") ||
+    (title.includes("extract") && /\b(constant|const|variable)\b/.test(title))
+  );
+}
+
+export function isDeleteDeadCodeCodeAction(action: CodeAction): boolean {
+  const kind = action.kind ?? "";
+  const title = action.title.trim().toLowerCase();
+  const kindMatches =
+    kind === "quickfix" ||
+    kind.startsWith("quickfix.") ||
+    kind === "refactor.rewrite" ||
+    kind.startsWith("refactor.rewrite.");
+  const titleMatches =
+    /(unused|dead code|remove unused|remove unreachable|remove declaration)/.test(title);
+  return kindMatches && titleMatches;
+}
+
+function convertCodeActionToResult(action: CodeAction): RefactorResult | null {
+  if (!action.edit) {
+    return null;
+  }
+  return convertLspWorkspaceEdit(action.edit);
+}
+
+function convertLspWorkspaceEdit(edit: WorkspaceEdit | null): RefactorResult {
+  if (!edit) {
+    return { kind: "unavailable", reason: "LSP server returned no edit" };
+  }
+
+  let fileEdits = edit.documentChanges?.length
+    ? collectDocumentChangeEdits(edit.documentChanges)
+    : [];
+  if (fileEdits.length === 0 && edit.changes) {
+    fileEdits = collectChangesEdits(edit.changes);
+  }
+
+  if (fileEdits.length === 0) {
+    return { kind: "unavailable", reason: "Workspace edit contains no file edits" };
+  }
+
+  return { kind: "precise", edits: { edits: fileEdits } };
+}
+
+function resolveFileFromUri(uri: string): string {
+  if (!uri.startsWith("file://")) return uri;
+  try {
+    return decodeURIComponent(uri.slice(7));
+  } catch {
+    return uri;
+  }
+}
+
+function collectDocumentChangeEdits(
+  docChanges: NonNullable<WorkspaceEdit["documentChanges"]>,
+): Array<{
+  file: string;
+  range: { start: { line: number; character: number }; end: { line: number; character: number } };
+  newText: string;
+}> {
+  const out: Array<{
+    file: string;
+    range: { start: { line: number; character: number }; end: { line: number; character: number } };
+    newText: string;
+  }> = [];
+  for (const change of docChanges) {
+    const tdEdit = change as TextDocumentEdit;
+    if (!tdEdit.textDocument || !tdEdit.edits) continue;
+    const file = resolveFileFromUri(tdEdit.textDocument.uri);
+    for (const singleEdit of tdEdit.edits) {
+      const te = singleEdit as TextEdit;
+      out.push({
+        file,
+        range: {
+          start: { line: te.range.start.line, character: te.range.start.character },
+          end: { line: te.range.end.line, character: te.range.end.character },
+        },
+        newText: te.newText,
+      });
+    }
+  }
+  return out;
+}
+
+function collectChangesEdits(changes: NonNullable<WorkspaceEdit["changes"]>): Array<{
+  file: string;
+  range: { start: { line: number; character: number }; end: { line: number; character: number } };
+  newText: string;
+}> {
+  const out: Array<{
+    file: string;
+    range: { start: { line: number; character: number }; end: { line: number; character: number } };
+    newText: string;
+  }> = [];
+  for (const [uri, textEdits] of Object.entries(changes)) {
+    if (!textEdits || textEdits.length === 0) continue;
+    const file = resolveFileFromUri(uri);
+    for (const te of textEdits) {
+      out.push({
+        file,
+        range: {
+          start: { line: te.range.start.line, character: te.range.start.character },
+          end: { line: te.range.end.line, character: te.range.end.character },
+        },
+        newText: te.newText,
+      });
+    }
+  }
+  return out;
+}

package/src/session/runtime-controller.ts

@@ -0,0 +1,320 @@
+// LSP session runtime controller — pi-independent lifecycle for LSP session management.
+//
+// This controller owns session start/shutdown for one cwd:
+//   - Creates and disposes the LspManager
+//   - Publishes SessionLspService states through the existing registry
+//   - Exposes the data the umbrella adapter will need later
+//
+// It does NOT import pi event types or ExtensionAPI.
+
+import type { WorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
+import { loadConfig } from "../config/config.ts";
+import { type LspSettings, loadLspSettings } from "../config/lsp-settings.ts";
+import { clearTsconfigCache } from "../config/tsconfig-scope.ts";
+import type { DetectedProjectServer, LspConfig, ProjectServerInfo } from "../config/types.ts";
+import { scanWorkspaceSentinels } from "../diagnostics/workspace-sentinels.ts";
+import { LspManager } from "../manager/manager.ts";
+import {
+  markLspCapabilitiesReady,
+  registerPendingLspCapabilities,
+  unregisterLspCapabilities,
+} from "./runtime-registration.ts";
+import { scanMissingServers, scanProjectCapabilities, startDetectedServers } from "./scanner.ts";
+import {
+  clearSessionLspService,
+  SessionLspService,
+  setSessionLspServiceState,
+} from "./service-registry.ts";
+
+// ── Types ─────────────────────────────────────────────────────────────
+
+/** Starting state before {@link LspRuntimeController.start} is called. */
+export type LspControllerState =
+  | LspControllerInitial
+  | LspControllerPending
+  | LspControllerReady
+  | LspControllerDisabled
+  | LspControllerUnavailable;
+
+interface LspControllerInitial {
+  kind: "initial";
+}
+
+interface LspControllerPending {
+  kind: "pending";
+}
+
+interface LspControllerReady {
+  kind: "ready";
+  manager: LspManager;
+  service: SessionLspService;
+  projectServers: ProjectServerInfo[];
+  detectedServers: DetectedProjectServer[];
+  settings: LspSettings;
+}
+
+interface LspControllerDisabled {
+  kind: "disabled";
+  message: string;
+}
+
+interface LspControllerUnavailable {
+  kind: "unavailable";
+  reason: string;
+}
+
+/** Result type from {@link LspRuntimeController.start}. */
+export type LspStartResult =
+  | { kind: "ready"; manager: LspManager; service: SessionLspService }
+  | { kind: "disabled"; message: string }
+  | { kind: "unavailable"; reason: string };
+
+// ── Controller ────────────────────────────────────────────────────────
+
+/**
+ * Pi-independent LSP session lifecycle controller.
+ *
+ * Use this in the umbrella extension (supi-code-intelligence) instead of
+ * reaching into substrate extension internals.
+ *
+ * @example
+ * ```ts
+ * const controller = new LspRuntimeController(cwd);
+ * const result = await controller.start();
+ * if (result.kind === "ready") {
+ *   // use controller.manager, controller.service
+ * }
+ * // later
+ * await controller.shutdown();
+ * ```
+ */
+export class LspRuntimeController {
+  readonly #cwd: string;
+  #state: LspControllerState;
+  #runtime: WorkspaceRuntime | null;
+  #readinessGeneration = 0;
+
+  constructor(cwd: string, runtime?: WorkspaceRuntime) {
+    this.#cwd = cwd;
+    this.#state = { kind: "initial" };
+    this.#runtime = runtime ?? null;
+  }
+
+  /** The workspace cwd this controller was created for. */
+  get cwd(): string {
+    return this.#cwd;
+  }
+
+  /** Current controller state. */
+  get kind(): LspControllerState["kind"] {
+    return this.#state.kind;
+  }
+
+  /** The LspManager, only available when state is "ready". */
+  get manager(): LspManager | null {
+    return this.#state.kind === "ready" ? this.#state.manager : null;
+  }
+
+  /** The SessionLspService, only available when state is "ready". */
+  get service(): SessionLspService | null {
+    return this.#state.kind === "ready" ? this.#state.service : null;
+  }
+
+  /** Project server info, only available when state is "ready". */
+  get projectServers(): ProjectServerInfo[] {
+    if (this.#state.kind === "ready") return this.#state.projectServers;
+    return [];
+  }
+
+  /** Detected servers, only available when state is "ready". */
+  get detectedServers(): DetectedProjectServer[] {
+    if (this.#state.kind === "ready") return this.#state.detectedServers;
+    return [];
+  }
+
+  /** LSP settings used for this session. */
+  get settings(): LspSettings | null {
+    if (this.#state.kind === "ready") return this.#state.settings;
+    return null;
+  }
+
+  /** The WorkspaceRuntime registered for this session's cwd. */
+  get runtime(): WorkspaceRuntime | null {
+    return this.#runtime;
+  }
+
+  /** Attach a WorkspaceRuntime for capability registration. */
+  setRuntime(runtime: WorkspaceRuntime): void {
+    this.#runtime = runtime;
+  }
+
+  /**
+   * Start the LSP session for this controller's cwd.
+   *
+   * Loads settings, creates the manager, starts detected servers,
+   * publishes the session service, and registers capabilities.
+   *
+   * Always attempts detected servers unless they were explicitly disabled
+   * per language via `lsp.servers.<language>.enabled: false`.
+   * The global `lsp.enabled` and `lsp.active` keys are deprecated and ignored.
+   *
+   * Returns the start result and updates the controller's state.
+   */
+  async start(): Promise<LspStartResult> {
+    clearTsconfigCache();
+
+    // Restart safety: shut down any existing session before creating a new one
+    await this.cleanupExistingSession();
+
+    const lspSettings = loadLspSettings(this.#cwd);
+    // Note: lspSettings.enabled is ignored — the global switch is deprecated.
+    // Per-language `lsp.servers.<language>.enabled: false` is the supported
+    // way to opt out and is already handled by loadConfig.
+    // lspSettings.active is also ignored — the allowlist is deprecated.
+
+    const config = loadConfig(this.#cwd);
+
+    try {
+      return await this.initializeLspSession(config, lspSettings);
+    } catch (error: unknown) {
+      return this.setUnavailable(error);
+    }
+  }
+
+  /**
+   * Shut down any existing LSP session before starting a new one.
+   */
+  private async cleanupExistingSession(): Promise<void> {
+    this.#readinessGeneration++;
+    if (this.#state.kind !== "ready") return;
+    await this.#state.manager.shutdownAll();
+    if (this.#runtime) unregisterLspCapabilities(this.#runtime, this.#cwd);
+    clearSessionLspService(this.#cwd);
+  }
+
+  /** Set controller state to unavailable with the given error. */
+  private setUnavailable(error: unknown): LspStartResult {
+    const reason = error instanceof Error ? error.message : String(error);
+    this.#state = { kind: "unavailable", reason };
+    setSessionLspServiceState(this.#cwd, { kind: "unavailable", reason });
+    return { kind: "unavailable", reason };
+  }
+
+  /**
+   * Initialize the LSP session: create manager, detect and start servers,
+   * publish service state and capabilities.
+   */
+  private async initializeLspSession(
+    config: LspConfig,
+    settings: LspSettings,
+  ): Promise<LspStartResult> {
+    clearSessionLspService(this.#cwd);
+    this.#state = { kind: "pending" };
+
+    const manager = new LspManager(config, this.#cwd);
+    manager.setExcludePatterns(settings.exclude);
+    setSessionLspServiceState(this.#cwd, { kind: "pending" });
+
+    const detectedServers = scanProjectCapabilities(config, this.#cwd);
+    manager.registerDetectedServers(detectedServers);
+    await startDetectedServers(manager, detectedServers);
+
+    scanWorkspaceSentinels(this.#cwd);
+
+    const service = new SessionLspService(manager);
+    setSessionLspServiceState(this.#cwd, { kind: "ready", service });
+
+    if (this.#runtime) {
+      registerPendingLspCapabilities(this.#runtime, this.#cwd, service);
+    }
+
+    const projectServers = manager.getKnownProjectServers(detectedServers);
+
+    this.#state = {
+      kind: "ready",
+      manager,
+      service,
+      projectServers,
+      detectedServers,
+      settings,
+    };
+
+    const readinessGeneration = ++this.#readinessGeneration;
+    void this.promoteSemanticReadiness(manager, detectedServers, readinessGeneration);
+
+    return { kind: "ready", manager, service };
+  }
+
+  private async promoteSemanticReadiness(
+    manager: LspManager,
+    detectedServers: DetectedProjectServer[],
+    readinessGeneration: number,
+  ): Promise<void> {
+    try {
+      await manager.waitUntilWorkspaceReady();
+    } catch {
+      this.retractPendingCapabilities();
+      return;
+    }
+
+    if (
+      readinessGeneration !== this.#readinessGeneration ||
+      this.#state.kind !== "ready" ||
+      this.#state.manager !== manager
+    ) {
+      return;
+    }
+
+    this.#state.projectServers = manager.getKnownProjectServers(detectedServers);
+    if (this.#runtime) {
+      markLspCapabilitiesReady(this.#runtime, this.#cwd);
+    }
+  }
+
+  /**
+   * Retract the pending semantic registration when warm-up fails.
+   * Leaves the workspace in unavailable state so callers see a definitive
+   * failure rather than an orphaned pending capability.
+   */
+  private retractPendingCapabilities(): void {
+    if (this.#runtime) {
+      unregisterLspCapabilities(this.#runtime, this.#cwd);
+    }
+    setSessionLspServiceState(this.#cwd, {
+      kind: "unavailable",
+      reason: "LSP warm-up failed. Check code_health for server status.",
+    });
+  }
+
+  /**
+   * Shut down the LSP session.
+   *
+   * Unregisters capabilities, clears the service state, and shuts down
+   * all LSP clients.
+   */
+  async shutdown(): Promise<void> {
+    this.#readinessGeneration++;
+    clearTsconfigCache();
+
+    if (this.#runtime) {
+      unregisterLspCapabilities(this.#runtime, this.#cwd);
+    }
+
+    if (this.#cwd) {
+      clearSessionLspService(this.#cwd);
+    }
+
+    if (this.#state.kind === "ready") {
+      await this.#state.manager.shutdownAll();
+    }
+
+    this.#state = { kind: "initial" };
+  }
+
+  /** Get the missing servers warning (servers whose binary is not on PATH). */
+  getMissingServers(): Array<{ name: string; command: string }> {
+    if (this.#state.kind !== "ready") return [];
+    const config = loadConfig(this.#cwd);
+    return scanMissingServers(config, this.#cwd);
+  }
+}

package/src/session/runtime-registration.ts

@@ -11,12 +11,28 @@ import { createLspSemanticProvider } from "../provider/lsp-semantic-provider.ts"
 import type { SessionLspService } from "./service-registry.ts";
 
 /**
- * Register LSP capabilities for a workspace cwd.
+ * Register LSP capabilities for a workspace cwd in pending state.
  *
- * Wraps SessionLspService into a SemanticProvider via the existing
- * semantic adapter and publishes it into the shared workspace runtime
- * so that code-intelligence and other consumers can discover semantic
- * analysis availability.
+ * Use this once the session service exists but before the language server has
+ * finished its initial readiness pipeline. Calls can then be deferred instead
+ * of silently observing "no provider" during startup.
+ */
+export function registerPendingLspCapabilities(
+  runtime: WorkspaceRuntime,
+  cwd: string,
+  service: SessionLspService,
+): void {
+  const provider = createLspSemanticProvider(service);
+  runtime.registerSemanticPending(cwd, provider);
+}
+
+/**
+ * Register LSP capabilities for a workspace cwd as ready.
+ *
+ * Wraps SessionLspService into a SemanticProvider via the existing semantic
+ * adapter and publishes it into the shared workspace runtime so that
+ * code-intelligence and other consumers can discover semantic analysis
+ * availability.
  */
 export function registerLspCapabilities(
   runtime: WorkspaceRuntime,
@@ -27,6 +43,11 @@ export function registerLspCapabilities(
   runtime.registerSemantic(cwd, provider);
 }
 
+/** Promote an already-registered pending semantic provider to ready. */
+export function markLspCapabilitiesReady(runtime: WorkspaceRuntime, cwd: string): void {
+  runtime.markSemanticReady(cwd);
+}
+
 /**
  * Unregister LSP capabilities for a workspace cwd.
  *