@mrclrchtr/supi-lsp 1.7.0 → 1.9.0

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

@@ -0,0 +1,156 @@
+// LSP semantic provider adapter — wraps SessionLspService into the shared
+// SemanticProvider contract from supi-code-runtime.
+
+import type {
+  CodeLocation,
+  CodePosition,
+  CodeSymbol,
+  SemanticProvider,
+} from "@mrclrchtr/supi-code-runtime/api";
+import type { DocumentSymbol, Location, LocationLink, SymbolInformation } from "../config/types.ts";
+import type { SessionLspService } from "../session/service-registry.ts";
+
+/**
+ * Create a SemanticProvider backed by a SessionLspService.
+ * Maps LSP types into the shared code-runtime types.
+ */
+export function createLspSemanticProvider(lsp: SessionLspService): SemanticProvider {
+  return {
+    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 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 documentSymbols(filePath: string): Promise<CodeSymbol[] | null> {
+      const symbols = await lsp.documentSymbols(filePath);
+      if (!symbols) return null;
+      return flattenDocumentSymbols(symbols, filePath);
+    },
+
+    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));
+    },
+  };
+}
+
+// ── Type conversion helpers ───────────────────────────────────────────
+
+function toCodeLocation(item: Location | LocationLink): CodeLocation | null {
+  const loc = item as Record<string, unknown>;
+  const uri = loc.uri ?? loc.targetUri;
+  if (typeof uri !== "string") return null;
+
+  // Prefer targetSelectionRange > targetRange > range
+  const range = loc.targetSelectionRange ?? loc.targetRange ?? loc.range;
+  if (!range || typeof range !== "object") return null;
+
+  const r = range as { start: Record<string, unknown>; end: Record<string, unknown> };
+  const start = r.start;
+  const end = r.end;
+  if (!start || !end) return null;
+
+  return {
+    uri,
+    range: {
+      start: { line: (start.line as number) ?? 0, character: (start.character as number) ?? 0 },
+      end: { line: (end.line as number) ?? 0, character: (end.character as number) ?? 0 },
+    },
+  };
+}
+
+const SYMBOL_KIND_NAMES: Record<number, string> = {
+  1: "File",
+  2: "Module",
+  3: "Namespace",
+  4: "Package",
+  5: "Class",
+  6: "Method",
+  7: "Property",
+  8: "Field",
+  9: "Constructor",
+  10: "Enum",
+  11: "Interface",
+  12: "Function",
+  13: "Variable",
+  14: "Constant",
+  15: "String",
+  16: "Number",
+  17: "Boolean",
+  18: "Array",
+  19: "Object",
+  20: "Key",
+  21: "Null",
+  22: "EnumMember",
+  23: "Struct",
+  24: "Event",
+  25: "Operator",
+  26: "TypeParameter",
+};
+
+function symbolKindName(kind: number): string {
+  return SYMBOL_KIND_NAMES[kind] ?? "Unknown";
+}
+
+function flattenDocumentSymbols(
+  symbols: DocumentSymbol[] | SymbolInformation[],
+  filePath: string,
+  container: string | null = null,
+): CodeSymbol[] {
+  const result: CodeSymbol[] = [];
+
+  for (const sym of symbols) {
+    // DocumentSymbol has selectionRange; SymbolInformation has location
+    const ds = sym as DocumentSymbol;
+    const si = sym as SymbolInformation;
+    const start = ds.selectionRange?.start ?? si.location?.range?.start;
+    if (!start) continue;
+
+    result.push({
+      name: sym.name,
+      kind: symbolKindName(sym.kind),
+      file: filePath,
+      line: start.line + 1,
+      character: start.character + 1,
+      container,
+    });
+
+    if (Array.isArray(ds.children) && ds.children.length > 0) {
+      result.push(...flattenDocumentSymbols(ds.children, filePath, sym.name));
+    }
+  }
+
+  return result;
+}
+
+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,
+    line: start ? start.line + 1 : 0,
+    character: start ? start.character + 1 : 0,
+    container: sym.containerName ?? null,
+  };
+}

package/src/session/runtime-registration.ts

@@ -0,0 +1,39 @@
+/**
+ * LSP-to-runtime capability registration.
+ *
+ * Adapts a SessionLspService into the runtime's SemanticProvider interface
+ * and registers/unregisters it with the shared WorkspaceRuntime at session
+ * lifecycle boundaries.
+ */
+
+import type { WorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
+import { createLspSemanticProvider } from "../provider/lsp-semantic-provider.ts";
+import type { SessionLspService } from "./service-registry.ts";
+
+/**
+ * Register LSP capabilities for a workspace cwd.
+ *
+ * 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,
+  cwd: string,
+  service: SessionLspService,
+): void {
+  const provider = createLspSemanticProvider(service);
+  runtime.registerSemantic(cwd, provider);
+}
+
+/**
+ * Unregister LSP capabilities for a workspace cwd.
+ *
+ * Clears only the semantic capability slot — structural (tree-sitter)
+ * state is left intact so that a later tree-sitter session_start does
+ * not needlessly wipe LSP state on its own restart path.
+ */
+export function unregisterLspCapabilities(runtime: WorkspaceRuntime, cwd: string): void {
+  runtime.clearSemantic(cwd);
+}

package/src/session/scanner.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { dedupeTopmostRoots, walkProject } from "@mrclrchtr/supi-core/api";
+import { dedupeTopmostRoots, walkProject } from "@mrclrchtr/supi-core/project";
 import type {
   DetectedProjectServer,
   LspConfig,

package/src/session/service-registry.ts

@@ -2,7 +2,7 @@
 // Peer extensions can import `getSessionLspService` from the package root
 // to reuse the active LSP runtime without starting duplicate servers.
 
-import { createSessionStateRegistry } from "@mrclrchtr/supi-core/api";
+import { createSessionStateRegistry } from "@mrclrchtr/supi-core/session";
 import type {
   CodeAction,
   Diagnostic,

package/src/session/settings-registration.ts

@@ -7,7 +7,7 @@ import {
   loadSupiConfig,
   loadSupiConfigForScope,
   registerConfigSettings,
-} from "@mrclrchtr/supi-core/api";
+} from "@mrclrchtr/supi-core/config";
 import { loadConfig } from "../config/config.ts";
 
 // ── Types ────────────────────────────────────────────────────

package/src/tool/guidance.ts

@@ -2,7 +2,7 @@
 
 import * as path from "node:path";
 import type { ProjectServerInfo } from "../config/server-config.ts";
-import { LSP_LOOKUP_TOOL, type LspToolName } from "./names.ts";
+import { LSP_HOVER_TOOL, type LspToolName } from "./names.ts";
 import { LSP_TOOL_DEFINITION_SPECS } from "./tool-specs.ts";
 
 export interface LspToolPromptSurface {
@@ -28,7 +28,7 @@ export function buildLspToolPromptSurfaces(
         description: spec.description,
         promptSnippet: spec.promptSnippet,
         promptGuidelines:
-          "includeCoverageGuidelines" in spec && spec.includeCoverageGuidelines
+          spec.name === LSP_HOVER_TOOL && coverageGuidelines.length > 0
             ? [...spec.basePromptGuidelines, ...coverageGuidelines]
             : [...spec.basePromptGuidelines],
       } satisfies LspToolPromptSurface,
@@ -43,8 +43,8 @@ function buildCoverageGuidelines(servers: ProjectServerInfo[], cwd: string): str
       const root = displayRoot(server.root, cwd);
       const fileTypes = server.fileTypes.map((entry) => `.${entry}`).join(",");
       const actions = server.supportedActions.join(",");
-      const actionText = actions.length > 0 ? ` | actions: ${actions}` : "";
-      return `lsp server coverage: ${server.name} | root: ${root} | files: ${fileTypes}${actionText}`;
+      const actionText = actions.length > 0 ? ` | actions:${actions}` : "";
+      return `lsp server coverage: ${server.name} | root:${root} | files:${fileTypes}${actionText}`;
     });
 
   const unavailable = servers
@@ -54,7 +54,7 @@ function buildCoverageGuidelines(servers: ProjectServerInfo[], cwd: string): str
   const dynamic = [...active];
   if (unavailable.length > 0) {
     dynamic.push(
-      `lsp server unavailable: ${unavailable.join(",")} — install or enable to extend semantic coverage`,
+      `lsp server unavailable: ${unavailable.join(",")} — install or enable for more coverage`,
     );
   }
 
@@ -67,12 +67,3 @@ function displayRoot(root: string, cwd: string): string {
   if (relative.startsWith(`..${path.sep}`) || relative === "..") return root;
   return relative.replaceAll(path.sep, "/");
 }
-
-// Compatibility exports for older internal tests and helper imports.
-export const toolDescription = defaultLspToolPromptSurfaces[LSP_LOOKUP_TOOL].description;
-export const promptSnippet = defaultLspToolPromptSurfaces[LSP_LOOKUP_TOOL].promptSnippet;
-export const promptGuidelines = defaultLspToolPromptSurfaces[LSP_LOOKUP_TOOL].promptGuidelines;
-
-export function buildProjectGuidelines(servers: ProjectServerInfo[], cwd: string): string[] {
-  return buildLspToolPromptSurfaces(servers, cwd)[LSP_LOOKUP_TOOL].promptGuidelines;
-}

package/src/tool/names.ts

@@ -1,18 +1,26 @@
 // Stable LSP tool names shared across registration, guidance, and runtime state.
 
-export const LSP_LOOKUP_TOOL = "lsp_lookup";
+export const LSP_HOVER_TOOL = "lsp_hover";
+export const LSP_DEFINITION_TOOL = "lsp_definition";
+export const LSP_REFERENCES_TOOL = "lsp_references";
+export const LSP_IMPLEMENTATION_TOOL = "lsp_implementation";
 export const LSP_DOCUMENT_SYMBOLS_TOOL = "lsp_document_symbols";
 export const LSP_WORKSPACE_SYMBOLS_TOOL = "lsp_workspace_symbols";
 export const LSP_DIAGNOSTICS_TOOL = "lsp_diagnostics";
-export const LSP_REFACTOR_TOOL = "lsp_refactor";
+export const LSP_RENAME_TOOL = "lsp_rename";
+export const LSP_CODE_ACTIONS_TOOL = "lsp_code_actions";
 export const LSP_RECOVER_TOOL = "lsp_recover";
 
 export const LSP_TOOL_NAMES = [
-  LSP_LOOKUP_TOOL,
+  LSP_HOVER_TOOL,
+  LSP_DEFINITION_TOOL,
+  LSP_REFERENCES_TOOL,
+  LSP_IMPLEMENTATION_TOOL,
   LSP_DOCUMENT_SYMBOLS_TOOL,
   LSP_WORKSPACE_SYMBOLS_TOOL,
   LSP_DIAGNOSTICS_TOOL,
-  LSP_REFACTOR_TOOL,
+  LSP_RENAME_TOOL,
+  LSP_CODE_ACTIONS_TOOL,
   LSP_RECOVER_TOOL,
 ] as const;
 

package/src/tool/register-tools.ts

@@ -47,14 +47,12 @@ function createToolExecutor(
     params: unknown,
   ) => Promise<string>,
 ) {
-  // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
   return async (
     _toolCallId: string,
     params: unknown,
-    _signal: AbortSignal | undefined,
-    _onUpdate: unknown,
-    ctx: ExtensionContext,
+    ...rest: [AbortSignal | undefined, unknown, ExtensionContext]
   ) => {
+    const ctx = rest[2];
     const service = getReadyService(ctx.cwd);
     const text = service
       ? await run(service, ctx.cwd, params)

package/src/tool/service-actions.ts

@@ -128,6 +128,147 @@ export async function executeLookup(
   }
 }
 
+// ---------------------------------------------------------------------------
+// Focused lookup tools (replacing the old multiplexed executeLookup)
+// ---------------------------------------------------------------------------
+
+export interface LspPositionToolParams {
+  file: string;
+  line: number;
+  character: number;
+}
+
+export interface LspRenameToolParams {
+  file: string;
+  line: number;
+  character: number;
+  newName: string;
+}
+
+export async function executeHover(
+  service: SessionLspService,
+  cwd: string,
+  params: LspPositionToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+    const position = toZeroBased(params.line, params.character);
+    const hover = await service.hover(params.file, position);
+    return hover ? formatHover(hover) : "No hover information available at this position.";
+  } catch (error) {
+    return formatUnexpectedFailure("hover", error);
+  }
+}
+
+export async function executeDefinition(
+  service: SessionLspService,
+  cwd: string,
+  params: LspPositionToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+    const position = toZeroBased(params.line, params.character);
+    const result = await service.definition(params.file, position);
+    if (!result) return "No definition found.";
+    const locations = normalizeLocations(result);
+    return locations.length > 0
+      ? formatLocations("Definition", locations, cwd)
+      : "No definition found.";
+  } catch (error) {
+    return formatUnexpectedFailure("definition", error);
+  }
+}
+
+export async function executeReferences(
+  service: SessionLspService,
+  cwd: string,
+  params: LspPositionToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+    const position = toZeroBased(params.line, params.character);
+    const references = await service.references(params.file, position);
+    return references && references.length > 0
+      ? formatLocations("References", references, cwd)
+      : "No references found.";
+  } catch (error) {
+    return formatUnexpectedFailure("references", error);
+  }
+}
+
+export async function executeImplementation(
+  service: SessionLspService,
+  cwd: string,
+  params: LspPositionToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+    const position = toZeroBased(params.line, params.character);
+    const result = await service.implementation(params.file, position);
+    if (!result) return "No implementation found.";
+    const locations = normalizeLocations(result);
+    return locations.length > 0
+      ? formatLocations("Implementation", locations, cwd)
+      : "No implementation found.";
+  } catch (error) {
+    return formatUnexpectedFailure("implementation", error);
+  }
+}
+
+export async function executeRename(
+  service: SessionLspService,
+  cwd: string,
+  params: LspRenameToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+    const newName = params.newName?.trim();
+    if (!newName) {
+      return "Validation error: `newName` is required for rename.";
+    }
+    const position = toZeroBased(params.line, params.character);
+    const edit = await service.rename(params.file, position, newName);
+    return edit ? formatWorkspaceEdit(edit, cwd) : "Rename not available at this position.";
+  } catch (error) {
+    return formatUnexpectedFailure("rename", error);
+  }
+}
+
+export async function executeCodeActions(
+  service: SessionLspService,
+  cwd: string,
+  params: LspPositionToolParams,
+): Promise<string> {
+  try {
+    const positionError = validatePositivePosition(params.line, params.character);
+    if (positionError) return positionError;
+    const fileError = validateFile(service, cwd, params.file);
+    if (fileError) return fileError;
+    const position = toZeroBased(params.line, params.character);
+    const actions = await service.codeActions(params.file, position);
+    return actions && actions.length > 0
+      ? formatCodeActions(actions)
+      : "No code actions available at this position.";
+  } catch (error) {
+    return formatUnexpectedFailure("code actions", error);
+  }
+}
+
 export async function executeDocumentSymbols(
   service: SessionLspService,
   cwd: string,