@mrclrchtr/supi-lsp 3.2.0 → 4.1.0

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

@@ -1,16 +1,24 @@
-// LSP semantic provider adapter — wraps SessionLspService into the shared
+// LSP semantic provider adapter — wraps WorkspaceLspRuntime into the shared
 // SemanticProvider contract from supi-code-runtime.
 
+import { readFile } from "node:fs/promises";
 import {
   type CodeLocation,
   type CodePosition,
+  type CodeQueryResult,
   type CodeSymbol,
-  normalizeRefactorOperation,
+  completedCodeQuery,
+  type DeclarationNesting,
+  type DocumentCodeSymbol,
+  mapCodeQueryResult,
+  partialCodeQuery,
   type RefactorRequest,
   type RefactorResult,
   type SemanticProvider,
   type SourceRange,
+  unavailableCodeQuery,
 } from "@mrclrchtr/supi-code-runtime/api";
+import { uriToFile } from "@mrclrchtr/supi-core/path";
 import type {
   CodeAction,
   DocumentSymbol,
@@ -20,7 +28,7 @@ import type {
   MarkupContent,
   SymbolInformation,
 } from "../config/types.ts";
-import type { SessionLspService } from "../session/service-registry.ts";
+import type { WorkspaceLspRuntime } from "../session/runtime-registry.ts";
 import {
   collectCodeActionResults,
   isDeleteDeadCodeCodeAction,
@@ -32,74 +40,62 @@ import {
 } from "./refactor-planning.ts";
 
 /**
- * Create a SemanticProvider backed by a SessionLspService.
+ * Create a SemanticProvider backed by a WorkspaceLspRuntime.
  * Maps LSP types into the shared code-runtime types.
  */
-export function createLspSemanticProvider(lsp: SessionLspService): SemanticProvider {
+export function createLspSemanticProvider(lsp: WorkspaceLspRuntime): SemanticProvider {
   return {
-    async definition(filePath: string, position: CodePosition): Promise<CodeLocation[] | null> {
-      const result = await lsp.definition(filePath, position);
-      if (!result) return null;
-      const normalized = Array.isArray(result) ? result : [result];
-      const mapped: CodeLocation[] = [];
-      for (const item of normalized) {
-        const loc = toCodeLocation(item);
-        if (loc) mapped.push(loc);
-      }
-      return mapped;
+    async definition(
+      filePath: string,
+      position: CodePosition,
+    ): Promise<CodeQueryResult<CodeLocation[]>> {
+      return mapCodeQueryResult(await lsp.definition(filePath, position), mapLocations);
     },
 
     async hover(
       filePath: string,
       position: CodePosition,
-    ): Promise<{ contents: string; range?: SourceRange } | null> {
-      const result = await lsp.hover(filePath, position);
-      if (!result) return null;
-      return convertLspHover(result);
+    ): Promise<CodeQueryResult<{ contents: string; range?: SourceRange } | null>> {
+      return mapCodeQueryResult(await lsp.hover(filePath, position), (hover) =>
+        hover ? convertLspHover(hover) : null,
+      );
     },
 
-    async references(filePath: string, position: CodePosition): Promise<CodeLocation[] | null> {
-      const refResult = await lsp.references(filePath, position);
-      if (!refResult) return null;
-      const mapped: CodeLocation[] = [];
-      for (const item of refResult) {
-        const loc = toCodeLocation(item);
-        if (loc) mapped.push(loc);
-      }
-      return mapped;
+    async references(
+      filePath: string,
+      position: CodePosition,
+    ): Promise<CodeQueryResult<CodeLocation[]>> {
+      return mapCodeQueryResult(await lsp.references(filePath, position), mapLocations);
     },
 
-    async implementation(filePath: string, position: CodePosition): Promise<CodeLocation[] | null> {
-      const implResult = await lsp.implementation(filePath, position);
-      if (!implResult) return null;
-      const normalized = Array.isArray(implResult) ? implResult : [implResult];
-      const mapped: CodeLocation[] = [];
-      for (const item of normalized) {
-        const loc = toCodeLocation(item);
-        if (loc) mapped.push(loc);
-      }
-      return mapped;
+    async implementation(
+      filePath: string,
+      position: CodePosition,
+    ): Promise<CodeQueryResult<CodeLocation[]>> {
+      return mapCodeQueryResult(await lsp.implementation(filePath, position), mapLocations);
     },
 
-    async documentSymbols(filePath: string): Promise<CodeSymbol[] | null> {
-      const symbols = await lsp.documentSymbols(filePath);
-      if (!symbols) return null;
-      return flattenDocumentSymbols(symbols, filePath);
+    async documentSymbols(filePath: string): Promise<CodeQueryResult<DocumentCodeSymbol[]>> {
+      const result = await lsp.documentSymbols(filePath);
+      if (result.kind === "unavailable") return unavailableCodeQuery(result.reason);
+      const sourceLines = await readSourceLines(filePath);
+      const symbols = flattenDocumentSymbols(result.data, filePath, null, {
+        sourceLines,
+        nesting: "top-level",
+      });
+      return result.kind === "partial"
+        ? partialCodeQuery(symbols, result.reason)
+        : completedCodeQuery(symbols);
     },
 
-    async workspaceSymbols(query: string): Promise<CodeSymbol[] | null> {
-      const results = await lsp.workspaceSymbol(query);
-      if (!results) return null;
-      return results.map((sym) => toCodeSymbol(sym as SymbolInformation));
+    async workspaceSymbols(query: string): Promise<CodeQueryResult<CodeSymbol[]>> {
+      return mapCodeQueryResult(await lsp.workspaceSymbol(query), (results) =>
+        results.map((symbol) => toCodeSymbol(symbol as SymbolInformation)),
+      );
     },
 
     async refactor(request: RefactorRequest): Promise<RefactorResult> {
-      // Normalize defensively at the provider boundary as well as in
-      // code-intelligence. RefactorRequest still permits the legacy `rename`
-      // alias, and the provider may be invoked directly outside the public tool.
-      const operation = normalizeRefactorOperation(request.operation);
-
-      switch (operation) {
+      switch (request.operation) {
         case "rename_symbol":
           if (!request.newName) {
             return {
@@ -134,13 +130,13 @@ export function createLspSemanticProvider(lsp: SessionLspService): SemanticProvi
           // shared file/resource edits and rollback semantics exist.
           return {
             kind: "unavailable",
-            reason: `Refactor operation "${operation}" is not supported yet. File/resource operations are deferred.`,
+            reason: `Refactor operation "${request.operation}" is not supported yet. File/resource operations are deferred.`,
           };
       }
 
       return {
         kind: "unavailable",
-        reason: `Refactor operation "${operation}" is not supported by the active semantic provider.`,
+        reason: `Refactor operation "${request.operation}" is not supported by the active semantic provider.`,
       };
     },
 
@@ -153,22 +149,11 @@ export function createLspSemanticProvider(lsp: SessionLspService): SemanticProvi
       if (!actions) return [];
       return collectCodeActionResults(actions);
     },
-
-    async codeActionTitles(
-      file: string,
-      position: CodePosition,
-    ): Promise<Array<{ title: string; kind?: string }> | null> {
-      const actions = await lsp.codeActions(file, position);
-      if (!actions) return null;
-      return actions
-        .filter((a) => a.title)
-        .map((a) => ({ title: a.title, kind: a.kind ?? undefined }));
-    },
   };
 }
 
 function runExtractRefactor(
-  lsp: SessionLspService,
+  lsp: WorkspaceLspRuntime,
   request: RefactorRequest,
   operation: "extract_function" | "extract_variable",
   matches: (action: CodeAction) => boolean,
@@ -192,6 +177,15 @@ function runExtractRefactor(
 
 // ── Type conversion helpers ───────────────────────────────────────────
 
+function mapLocations(value: Location | Location[] | LocationLink[] | null): CodeLocation[] {
+  if (!value) return [];
+  const locations = Array.isArray(value) ? value : [value];
+  return locations.flatMap((item) => {
+    const location = toCodeLocation(item);
+    return location ? [location] : [];
+  });
+}
+
 function toCodeLocation(item: Location | LocationLink): CodeLocation | null {
   const loc = item as Record<string, unknown>;
   const uri = loc.uri ?? loc.targetUri;
@@ -251,26 +245,35 @@ function symbolKindName(kind: number): string {
 function flattenDocumentSymbols(
   symbols: DocumentSymbol[] | SymbolInformation[],
   filePath: string,
-  container: string | null = null,
-): CodeSymbol[] {
-  const result: CodeSymbol[] = [];
+  container: string | null,
+  context: { sourceLines: readonly string[] | null; nesting: DeclarationNesting },
+): DocumentCodeSymbol[] {
+  const result: DocumentCodeSymbol[] = [];
 
   for (const sym of symbols) {
     // DocumentSymbol.range = full defining node (declaration anchor);
     // .selectionRange = identifier token (name anchor). SymbolInformation has
     // only location.range (declaration) and no selectionRange.
-    const ds = sym as DocumentSymbol;
-    const si = sym as SymbolInformation;
-    const declStart = ds.range?.start ?? si.location?.range?.start;
+    let document: DocumentSymbol | null = null;
+    let information: SymbolInformation | null = null;
+    if (isSymbolInformation(sym)) information = sym;
+    else document = sym;
+    const declStart = document?.range.start ?? information?.location.range.start;
     if (!declStart) continue;
-    const nameStart = ds.selectionRange?.start;
-
-    const symbol: CodeSymbol = {
+    const nameStart = document
+      ? resolveDocumentSymbolNameStart(document, context.sourceLines)
+      : null;
+    const reportedContainer = information?.containerName ?? container;
+    // SymbolInformation is flat: containerName remains metadata, not hierarchy evidence.
+    const nesting: DeclarationNesting = information ? "unknown" : context.nesting;
+
+    const symbol: DocumentCodeSymbol = {
       name: sym.name,
       kind: symbolKindName(sym.kind),
       file: filePath,
       declarationAnchor: { line: declStart.line + 1, character: declStart.character + 1 },
-      container,
+      container: reportedContainer,
+      nesting,
     };
     if (nameStart) {
       symbol.nameAnchor = { line: nameStart.line + 1, character: nameStart.character + 1 };
@@ -278,21 +281,71 @@ function flattenDocumentSymbols(
 
     result.push(symbol);
 
-    if (Array.isArray(ds.children) && ds.children.length > 0) {
-      result.push(...flattenDocumentSymbols(ds.children, filePath, sym.name));
+    if (document?.children && document.children.length > 0) {
+      result.push(
+        ...flattenDocumentSymbols(document.children, filePath, sym.name, {
+          sourceLines: context.sourceLines,
+          nesting: "nested",
+        }),
+      );
     }
   }
 
   return result;
 }
 
+function isSymbolInformation(
+  symbol: DocumentSymbol | SymbolInformation,
+): symbol is SymbolInformation {
+  return "location" in symbol;
+}
+
+async function readSourceLines(filePath: string): Promise<readonly string[] | null> {
+  try {
+    return (await readFile(filePath, "utf-8")).split(/\r?\n/);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Validate the LSP selection range against source text. Some servers return
+ * the full overload declaration as selectionRange; recover the exact symbol
+ * token on that line rather than labeling the declaration start as a name.
+ */
+function resolveDocumentSymbolNameStart(
+  symbol: DocumentSymbol,
+  sourceLines: readonly string[] | null,
+): { line: number; character: number } | null {
+  const selectionStart = symbol.selectionRange?.start;
+  if (!selectionStart) return null;
+  if (!sourceLines) return selectionStart;
+
+  const sourceLine = sourceLines[selectionStart.line];
+  if (sourceLine === undefined) return null;
+  if (
+    sourceLine.slice(selectionStart.character, selectionStart.character + symbol.name.length) ===
+    symbol.name
+  ) {
+    return selectionStart;
+  }
+
+  const rangeStart = symbol.range?.start;
+  const rangeEnd = symbol.range?.end;
+  const from = rangeStart?.line === selectionStart.line ? rangeStart.character : 0;
+  const until = rangeEnd?.line === selectionStart.line ? rangeEnd.character : sourceLine.length;
+  const repairedCharacter = sourceLine.indexOf(symbol.name, from);
+  if (repairedCharacter < 0 || repairedCharacter + symbol.name.length > until) return null;
+  return { line: selectionStart.line, character: repairedCharacter };
+}
+
 function toCodeSymbol(sym: SymbolInformation): CodeSymbol {
   const uri = sym.location?.uri ?? "";
   const start = sym.location?.range?.start;
   return {
     name: sym.name,
     kind: symbolKindName(sym.kind),
-    file: uri.startsWith("file://") ? decodeURIComponent(uri.slice(7)) : uri,
+    file: uriToFile(uri),
     // SymbolInformation has no selectionRange — nameAnchor is derived later
     // by the orchestration layer's refine, or left absent.
     declarationAnchor: {

package/src/provider/refactor-planning.ts

@@ -1,9 +1,10 @@
 import type { CodePosition, RefactorResult, SourceRange } from "@mrclrchtr/supi-code-runtime/api";
+import { uriToFile } from "@mrclrchtr/supi-core/path";
 import type { CodeAction, TextDocumentEdit, TextEdit, WorkspaceEdit } from "../config/types.ts";
-import type { SessionLspService } from "../session/service-registry.ts";
+import type { WorkspaceLspRuntime } from "../session/runtime-registry.ts";
 
 export async function runRenameRefactor(
-  lsp: SessionLspService,
+  lsp: WorkspaceLspRuntime,
   file: string,
   position: CodePosition,
   newName: string,
@@ -37,7 +38,7 @@ export function collectCodeActionResults(actions: CodeAction[]): RefactorResult[
 }
 
 export async function runFilteredCodeActionRefactor(options: {
-  lsp: SessionLspService;
+  lsp: WorkspaceLspRuntime;
   file: string;
   position: CodePosition;
   operation: "update_imports" | "delete_dead_code" | "extract_function" | "extract_variable";
@@ -146,15 +147,6 @@ function convertLspWorkspaceEdit(edit: WorkspaceEdit | null): RefactorResult {
   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<{
@@ -170,7 +162,7 @@ function collectDocumentChangeEdits(
   for (const change of docChanges) {
     const tdEdit = change as TextDocumentEdit;
     if (!tdEdit.textDocument || !tdEdit.edits) continue;
-    const file = resolveFileFromUri(tdEdit.textDocument.uri);
+    const file = uriToFile(tdEdit.textDocument.uri);
     for (const singleEdit of tdEdit.edits) {
       const te = singleEdit as TextEdit;
       out.push({
@@ -198,7 +190,7 @@ function collectChangesEdits(changes: NonNullable<WorkspaceEdit["changes"]>): Ar
   }> = [];
   for (const [uri, textEdits] of Object.entries(changes)) {
     if (!textEdits || textEdits.length === 0) continue;
-    const file = resolveFileFromUri(uri);
+    const file = uriToFile(uri);
     for (const te of textEdits) {
       out.push({
         file,

package/src/session/readiness.ts

@@ -0,0 +1,38 @@
+const DEFAULT_SEMANTIC_READY_TIMEOUT_MS = 15_000;
+
+export type ReadinessValueResult<T> =
+  | { kind: "resolved"; value: T }
+  | { kind: "timeout" }
+  | { kind: "unavailable"; reason: string };
+
+/** Await one readiness operation while preserving its concrete success value. */
+export async function raceReadinessValue<T>(
+  readiness: Promise<T>,
+  timeoutMs: number | undefined,
+): Promise<ReadinessValueResult<T>> {
+  const effectiveTimeoutMs = timeoutMs ?? DEFAULT_SEMANTIC_READY_TIMEOUT_MS;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  try {
+    const value = await Promise.race([
+      readiness,
+      new Promise<never>((_resolve, reject) => {
+        timer = setTimeout(
+          () => reject(new Error("semantic-readiness-timeout")),
+          effectiveTimeoutMs,
+        );
+      }),
+    ]);
+    return { kind: "resolved", value };
+  } catch (error) {
+    if (error instanceof Error && error.message === "semantic-readiness-timeout") {
+      return { kind: "timeout" };
+    }
+    return {
+      kind: "unavailable",
+      reason: error instanceof Error ? error.message : String(error),
+    };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}