@ian-pascoe/pi-lsp 0.1.0 → 0.2.0

package/src/lsp-server-manager.ts

@@ -18,6 +18,8 @@ export interface LspServerRoutingDefinition {
   readonly serverId: string;
   /** Languages and file patterns accepted by this server. */
   readonly languages: readonly LspServerLanguage[];
+  /** Exclude this server when none of its root markers exists above the requested file. */
+  readonly requireRootMarker?: boolean;
   /** Basename glob patterns that select this server instance's nearest workspace root. */
   readonly rootMarkers?: readonly string[];
 }
@@ -71,6 +73,7 @@ export type LspServerFailureCode =
   | "no-capable-server"
   | "no-matching-server"
   | "request-failed"
+  | "root-marker-not-found"
   | "server-unavailable";
 
 /** Preserves one matching server's failure without discarding sibling successes. */
@@ -79,8 +82,6 @@ export interface LspServerFailure {
   readonly code: LspServerFailureCode;
   /** Searchable caller-facing error prefixed with `Pi LSP:`. */
   readonly message: string;
-  /** Selected workspace root when routing reached a concrete Server Instance. */
-  readonly rootPath?: string;
   /** Configured server ID, or the requested missing ID. */
   readonly serverId: string;
 }
@@ -97,7 +98,7 @@ export interface LspServerSuccess<T> {
 
 /** Keeps successful multi-server reads useful when independent servers fail. */
 export interface LspServerReadResult<T> {
-  /** Labeled failures in deterministic route order. */
+  /** Labeled operational failures in deterministic route order. */
   readonly failures: readonly LspServerFailure[];
   /** Labeled successful values in deterministic route order. */
   readonly successes: readonly LspServerSuccess<T>[];
@@ -132,8 +133,6 @@ export interface LspServerStatusEntry {
 
 /** Reports configuration failures and session-scoped Server Instance states. */
 export interface LspServerManagerStatus {
-  /** False when either authored `lsp` settings layer was malformed. */
-  readonly enabled: boolean;
   /** Server entries ordered by ID and then root. */
   readonly servers: readonly LspServerStatusEntry[];
   /** Strict settings failures kept visible until Pi `/reload`. */
@@ -167,8 +166,11 @@ function findNearestLspRoot(
   rootMarkers: readonly string[] | undefined,
   ancestorDirectories: readonly LspAncestorDirectory[],
   cwd: string,
-): string {
-  if (rootMarkers === undefined || rootMarkers.length === 0) return resolve(cwd);
+  requireRootMarker: boolean,
+): string | undefined {
+  if (rootMarkers === undefined || rootMarkers.length === 0) {
+    return requireRootMarker ? undefined : resolve(cwd);
+  }
   for (const directory of ancestorDirectories) {
     if (
       directory.entryNames.some((entryName) =>
@@ -178,7 +180,7 @@ function findNearestLspRoot(
       return directory.path;
     }
   }
-  return resolve(cwd);
+  return requireRootMarker ? undefined : resolve(cwd);
 }
 
 /** Route one file to every matching configured server in stable settings-map order. */
@@ -196,10 +198,17 @@ export function routeLspServersForFile(
       languageMatchesFile(candidate, normalizedFilePath),
     );
     if (language === undefined) continue;
+    const rootPath = findNearestLspRoot(
+      serverDefinition.rootMarkers,
+      ancestorDirectories,
+      cwd,
+      serverDefinition.requireRootMarker ?? false,
+    );
+    if (rootPath === undefined) continue;
     routes.push({
       serverId: serverDefinition.serverId,
       language,
-      rootPath: findNearestLspRoot(serverDefinition.rootMarkers, ancestorDirectories, cwd),
+      rootPath,
     });
   }
 
@@ -235,7 +244,6 @@ function unavailableFailure(route: LspServerRoute, error: string): LspServerFail
   return {
     code: "server-unavailable",
     message: `Pi LSP: server ${route.serverId} is unavailable for ${route.rootPath}: ${error}`,
-    rootPath: route.rootPath,
     serverId: route.serverId,
   };
 }
@@ -275,26 +283,32 @@ export class LspServerManager<TClient extends LspManagedServerClient = LspManage
       }
     }
     return {
-      enabled: this.input.settings.enabled,
       servers,
       warnings: this.input.settings.warnings,
     };
   }
 
-  /** Resolve all matching Server Definitions and nearest roots without starting clients. */
-  async routeFile(filePath: string): Promise<readonly LspServerRoute[]> {
-    if (!this.input.settings.enabled) return [];
+  private async routeFile(filePath: string): Promise<readonly LspServerRoute[]> {
     const absolutePath = resolve(this.input.cwd, normalizeLspFilePath(filePath));
     const ancestors = await readLspAncestorDirectories(absolutePath);
     const definitions = [...this.input.settings.servers.values()].map((definition) => ({
       languages: definition.languages,
+      requireRootMarker: definition.requireRootMarker,
       rootMarkers: definition.rootMarkers,
       serverId: definition.id,
     }));
     return routeLspServersForFile(definitions, absolutePath, this.input.cwd, ancestors);
   }
 
-  /** Query every matching capable instance while retaining independent successes and failures. */
+  /** Report whether any Server Definition accepts the file language before activation gating. */
+  hasConfiguredLanguageServerForFile(filePath: string): boolean {
+    const absolutePath = resolve(this.input.cwd, normalizeLspFilePath(filePath));
+    return [...this.input.settings.servers.values()].some((definition) =>
+      definition.languages.some((language) => languageMatchesFile(language, absolutePath)),
+    );
+  }
+
+  /** Query matching capable instances while retaining independent operational failures. */
   async runRead<T>(
     filePath: string,
     serverId: string | undefined,
@@ -310,14 +324,14 @@ export class LspServerManager<TClient extends LspManagedServerClient = LspManage
     }
 
     const outcomes = await Promise.all(
-      routes.map(async (route): Promise<LspServerSuccess<T> | LspServerFailure> => {
+      routes.map(async (route): Promise<LspServerSuccess<T> | LspServerFailure | undefined> => {
         const resolution = await this.ensureClient(route);
         if (resolution.kind === "failure") return resolution.failure;
         if (!isCapable(resolution.instance.client)) {
+          if (serverId === undefined) return undefined;
           return {
             code: "no-capable-server",
             message: `Pi LSP: server ${route.serverId} does not support the requested operation`,
-            rootPath: route.rootPath,
             serverId: route.serverId,
           };
         }
@@ -331,7 +345,6 @@ export class LspServerManager<TClient extends LspManagedServerClient = LspManage
           return {
             code: "request-failed",
             message: `Pi LSP: server ${route.serverId} request failed: ${describeLspError(error)}`,
-            rootPath: route.rootPath,
             serverId: route.serverId,
           };
         }
@@ -341,9 +354,17 @@ export class LspServerManager<TClient extends LspManagedServerClient = LspManage
     const failures: LspServerFailure[] = [];
     const successes: LspServerSuccess<T>[] = [];
     for (const outcome of outcomes) {
+      if (outcome === undefined) continue;
       if ("code" in outcome) failures.push(outcome);
       else successes.push(outcome);
     }
+    if (failures.length === 0 && successes.length === 0) {
+      failures.push({
+        code: "no-capable-server",
+        message: "Pi LSP: no matching server supports the requested read operation",
+        serverId: "*",
+      });
+    }
     return { failures, successes };
   }
 
@@ -446,10 +467,23 @@ export class LspServerManager<TClient extends LspManagedServerClient = LspManage
   }
 
   private noMatchingFailure(serverId: string | undefined, filePath: string): LspServerFailure {
+    const normalizedFilePath = normalizeLspFilePath(filePath);
+    const definition =
+      serverId === undefined ? undefined : this.input.settings.servers.get(serverId);
+    if (
+      definition?.requireRootMarker === true &&
+      definition.languages.some((language) => languageMatchesFile(language, normalizedFilePath))
+    ) {
+      return {
+        code: "root-marker-not-found",
+        message: `Pi LSP: required root marker not found for server ${definition.id} and ${normalizedFilePath}; expected one of: ${definition.rootMarkers.join(", ")}`,
+        serverId: definition.id,
+      };
+    }
     const requestedServer = serverId === undefined ? "any configured server" : `server ${serverId}`;
     return {
       code: "no-matching-server",
-      message: `Pi LSP: ${requestedServer} does not match ${normalizeLspFilePath(filePath)}`,
+      message: `Pi LSP: ${requestedServer} does not match ${normalizedFilePath}`,
       serverId: serverId ?? "*",
     };
   }

package/src/lsp-session-files.ts

@@ -1,9 +1,6 @@
 import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
-/** The maximum retained byte length for one language server's stderr log. */
-export const MAX_SERVER_STDERR_BYTES = 1024 * 1024;
-
 /** Owns private Result Spill and bounded stderr files for one Pi session. */
 export interface LspSessionFiles {
   /** Private directory removed when the Pi session shuts down. */
@@ -12,15 +9,12 @@ export interface LspSessionFiles {
   writeResultSpill(output: string): Promise<string>;
   /** Create or return the bounded stderr file path for one language server. */
   getServerStderrPath(serverId: string): Promise<string>;
-  /** Retain the latest one megabyte of one language server's stderr stream. */
-  appendServerStderr(serverId: string, chunk: Uint8Array): Promise<string>;
   /** Remove all session files after queued writes finish. */
   close(): Promise<void>;
 }
 
 interface ServerStderrFile {
   readonly path: string;
-  content: Buffer;
 }
 
 class LspSessionFileStore implements LspSessionFiles {
@@ -45,22 +39,7 @@ class LspSessionFileStore implements LspSessionFiles {
   getServerStderrPath(serverId: string): Promise<string> {
     const stderrFile = this.serverStderrFile(serverId);
     return this.enqueueSessionFileWrite(async () => {
-      await writeFile(stderrFile.path, stderrFile.content, { mode: 0o600 });
-      await chmod(stderrFile.path, 0o600);
-      return stderrFile.path;
-    });
-  }
-
-  appendServerStderr(serverId: string, chunk: Uint8Array): Promise<string> {
-    const stderrFile = this.serverStderrFile(serverId);
-    const copiedChunk = Buffer.from(chunk);
-    return this.enqueueSessionFileWrite(async () => {
-      const combined = Buffer.concat([stderrFile.content, copiedChunk]);
-      stderrFile.content =
-        combined.length <= MAX_SERVER_STDERR_BYTES
-          ? combined
-          : Buffer.from(combined.subarray(combined.length - MAX_SERVER_STDERR_BYTES));
-      await writeFile(stderrFile.path, stderrFile.content, { mode: 0o600 });
+      await writeFile(stderrFile.path, "", { mode: 0o600 });
       await chmod(stderrFile.path, 0o600);
       return stderrFile.path;
     });
@@ -81,7 +60,6 @@ class LspSessionFileStore implements LspSessionFiles {
     if (existing !== undefined) return existing;
     const stderrFile = {
       path: join(this.directoryPath, `server-stderr-${this.nextFileIndex++}.log`),
-      content: Buffer.alloc(0),
     };
     this.stderrFiles.set(serverId, stderrFile);
     return stderrFile;

package/src/lsp-tool-contract.ts

@@ -332,7 +332,6 @@ const RegularFileSnapshotSchema = Type.Object(
   {
     kind: Type.Literal("file"),
     content_base64: Type.String(),
-    hash: Type.String({ minLength: 64, maxLength: 64 }),
     mode: Type.Integer({ minimum: 0 }),
   },
   { additionalProperties: false },
@@ -345,13 +344,17 @@ const SymlinkSnapshotSchema = Type.Object(
   },
   { additionalProperties: false },
 );
-const FileSnapshotSchema = Type.Union([
+/** Canonical pre-mutation snapshot of one filesystem path used by guarded rollback. */
+export const FileSnapshotSchema = Type.Union([
   MissingFileSnapshotSchema,
   RegularFileSnapshotSchema,
   SymlinkSnapshotSchema,
 ]);
-const ExistingFileSnapshotSchema = Type.Union([RegularFileSnapshotSchema, SymlinkSnapshotSchema]);
-const WorkspaceEditOperationSchema = Type.Union([
+export const ExistingFileSnapshotSchema = Type.Union([
+  RegularFileSnapshotSchema,
+  SymlinkSnapshotSchema,
+]);
+export const WorkspaceEditOperationSchema = Type.Union([
   Type.Object(
     {
       kind: Type.Literal("modify"),
@@ -440,7 +443,6 @@ const WorkspaceEditApplyDetailsSchema = Type.Object(
     changed_paths: Type.Array(AbsolutePathSchema),
     preview_records: Type.Optional(Type.Array(LspWorkspaceEditPreviewRecordSchema)),
     state: Type.Union([Type.Literal("applied"), Type.Literal("partial_failure")]),
-    recovery_failure_paths: Type.Optional(Type.Array(AbsolutePathSchema)),
   },
   { additionalProperties: false },
 );
@@ -460,9 +462,3 @@ export type LspWorkspaceEditPreviewRecord = Static<typeof LspWorkspaceEditPrevie
 
 /** A normalized per-server outcome used when rendering an LSP read operation. */
 export type ServerOperationOutcome = Static<typeof ServerOperationOutcomeSchema>;
-
-/** A persisted Workspace Edit Preview that can be rebuilt from the active session branch. */
-export type WorkspaceEditPreviewDetails = Static<typeof WorkspaceEditPreviewDetailsSchema>;
-
-/** The result of applying one guarded Workspace Edit Preview. */
-export type WorkspaceEditApplyDetails = Static<typeof WorkspaceEditApplyDetailsSchema>;

package/src/lsp-tool-output.ts

@@ -32,6 +32,24 @@ export function formatLspToolValue(value: LSPAny): string {
   return text === undefined ? "null" : text;
 }
 
+/** Truncate model-visible text against Pi limits, spilling the complete text when truncated. */
+export async function truncateLspOutputText(
+  text: string,
+  sessionFiles: LspSessionFiles,
+  subject: string,
+): Promise<{ readonly text: string; readonly spillPath?: string }> {
+  const truncation = truncateHead(text, {
+    maxBytes: DEFAULT_MAX_BYTES,
+    maxLines: DEFAULT_MAX_LINES,
+  });
+  if (!truncation.truncated) return { text };
+  const spillPath = await sessionFiles.writeResultSpill(text);
+  return {
+    text: `${truncation.content}\n\n[Pi LSP: ${subject} truncated; complete Result Spill: ${spillPath}]`,
+    spillPath,
+  };
+}
+
 /** Validate normalized details, truncate model-visible text, and spill every complete oversized result. */
 export async function createLspToolOutput(
   text: string,
@@ -39,26 +57,20 @@ export async function createLspToolOutput(
   sessionFiles: LspSessionFiles,
 ): Promise<AgentToolResult<LspToolResultDetails>> {
   const normalizedDetails = Value.Parse(LspToolResultDetailsSchema, details);
-  const truncated = truncateHead(text, {
-    maxBytes: DEFAULT_MAX_BYTES,
-    maxLines: DEFAULT_MAX_LINES,
-  });
-  if (!truncated.truncated) {
+  const truncated = await truncateLspOutputText(text, sessionFiles, "output");
+  if (truncated.spillPath === undefined) {
     return { content: [{ type: "text", text }], details: normalizedDetails };
   }
 
-  const spillPath = await sessionFiles.writeResultSpill(text);
-  const notice = `\n\n[Pi LSP: output truncated; complete Result Spill: ${spillPath}]`;
-  const visibleText = `${truncated.content}${notice}`;
   const detailsWithSpill =
     normalizedDetails.kind === "operation"
       ? Value.Parse(LspToolResultDetailsSchema, {
           ...normalizedDetails,
-          spill_path: spillPath,
+          spill_path: truncated.spillPath,
         })
       : normalizedDetails;
   return {
-    content: [{ type: "text", text: visibleText }],
+    content: [{ type: "text", text: truncated.text }],
     details: detailsWithSpill,
   };
 }

package/src/lsp-tool-rendering.ts

@@ -16,6 +16,7 @@ import {
   type LspToolResultDetails,
   type ServerOperationOutcome,
 } from "./lsp-tool-contract.js";
+import { pluralizedCount } from "./lsp-post-edit-diagnostics-rendering.js";
 
 /** Theme operations used by Pi LSP tool transcript rendering. */
 export type LspRenderTheme = Pick<Theme, "bold" | "fg">;
@@ -139,10 +140,6 @@ function semanticLspOperationMetric(
   return pluralizedCount(count, noun);
 }
 
-function pluralizedCount(count: number, noun: string): string {
-  return `${count} ${noun}${count === 1 ? "" : "s"}`;
-}
-
 function outcomeColor(outcome: ServerOperationOutcome["outcome"]): ThemeColor {
   switch (outcome) {
     case "success":

package/src/lsp-tool.ts

@@ -1,7 +1,11 @@
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import type { ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type {
+  AgentToolResult,
+  ExtensionContext,
+  ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
 import {
@@ -227,6 +231,23 @@ async function createLspToolOutput(
   );
 }
 
+async function readOutput(
+  operation: LspToolParameters["operation"],
+  result: Promise<LspServerReadResult<LSPAny>>,
+  dependencies: LspToolDependencies,
+) {
+  const resolved = await result;
+  requireReadSuccess(resolved);
+  return createLspToolOutput(
+    formatLspToolValue({
+      results: readOperationValue(resolved),
+      warnings: resolved.failures.map(({ message }) => message),
+    }),
+    operationDetails(operation, readOperationOutcomes(resolved)),
+    dependencies,
+  );
+}
+
 function parseLspToolParameters(input: LSPAny): LspToolParameters {
   try {
     return Value.Parse(LspToolParametersSchema, input);
@@ -440,15 +461,6 @@ async function normalizeProtocolResult(
   return Object.fromEntries(entries);
 }
 
-async function requestDocumentMethod(
-  prepared: PreparedDocument,
-  method: string,
-  parameters: LSPAny,
-  signal: AbortSignal | undefined,
-): Promise<LSPAny> {
-  return prepared.client.request<LSPAny>(method, parameters, signal);
-}
-
 function supportsResolveProvider(value: LSPAny): boolean {
   return protocolRecord(value)?.resolveProvider === true;
 }
@@ -545,9 +557,7 @@ async function workspacePreviewOutput(
   serverId: string,
   edit: WorkspaceEdit,
   positionEncoding: PositionEncodingKind,
-): Promise<
-  ReturnType<typeof createLspToolOutput> extends Promise<infer TResult> ? TResult : never
-> {
+): Promise<AgentToolResult<LspToolResultDetails>> {
   const preview = await dependencies.workspaceEdits.createPreview({
     edit,
     serverId,
@@ -617,8 +627,7 @@ async function executePositionRead(
           context: { includeDeclaration: parameters.include_declaration ?? true },
         };
       }
-      let value = await requestDocumentMethod(
-        prepared,
+      let value = await prepared.client.request<LSPAny>(
         capabilityMethod,
         requestParameters,
         signal,
@@ -1015,7 +1024,6 @@ async function executeApplyPreview(
         preview_id: parameters.preview_id,
         mutation_manifest: canonicalManifest,
         changed_paths: [...cause.recoveryFailures].sort((left, right) => left.localeCompare(right)),
-        recovery_failure_paths: [...cause.recoveryFailures],
         state: "partial_failure",
       },
       dependencies,
@@ -1127,72 +1135,42 @@ export function createLspToolDefinition(
         case "type_hierarchy":
         case "supertypes":
         case "subtypes":
-        case "prepare_rename": {
-          const result = await executePositionRead(dependencies, parameters, context, signal);
-          requireReadSuccess(result);
-          return createLspToolOutput(
-            formatLspToolValue({
-              results: readOperationValue(result),
-              warnings: result.failures.map(({ message }) => message),
-            }),
-            operationDetails(parameters.operation, readOperationOutcomes(result)),
+        case "prepare_rename":
+          return readOutput(
+            parameters.operation,
+            executePositionRead(dependencies, parameters, context, signal),
             dependencies,
           );
-        }
         case "diagnostics":
         case "document_symbols":
         case "document_links":
         case "folding_ranges":
         case "code_lenses":
-        case "document_colors": {
-          const result = await executeFileRead(dependencies, parameters, context, signal);
-          requireReadSuccess(result);
-          return createLspToolOutput(
-            formatLspToolValue({
-              results: readOperationValue(result),
-              warnings: result.failures.map(({ message }) => message),
-            }),
-            operationDetails(parameters.operation, readOperationOutcomes(result)),
+        case "document_colors":
+          return readOutput(
+            parameters.operation,
+            executeFileRead(dependencies, parameters, context, signal),
             dependencies,
           );
-        }
         case "workspace_diagnostics":
-        case "workspace_symbols": {
-          const result = await executeWorkspaceRead(dependencies, parameters, context, signal);
-          requireReadSuccess(result);
-          return createLspToolOutput(
-            formatLspToolValue({
-              results: readOperationValue(result),
-              warnings: result.failures.map(({ message }) => message),
-            }),
-            operationDetails(parameters.operation, readOperationOutcomes(result)),
+        case "workspace_symbols":
+          return readOutput(
+            parameters.operation,
+            executeWorkspaceRead(dependencies, parameters, context, signal),
             dependencies,
           );
-        }
-        case "selection_ranges": {
-          const result = await executeSelectionRanges(dependencies, parameters, context, signal);
-          requireReadSuccess(result);
-          return createLspToolOutput(
-            formatLspToolValue({
-              results: readOperationValue(result),
-              warnings: result.failures.map(({ message }) => message),
-            }),
-            operationDetails(parameters.operation, readOperationOutcomes(result)),
+        case "selection_ranges":
+          return readOutput(
+            parameters.operation,
+            executeSelectionRanges(dependencies, parameters, context, signal),
             dependencies,
           );
-        }
-        case "inlay_hints": {
-          const result = await executeInlayHints(dependencies, parameters, context, signal);
-          requireReadSuccess(result);
-          return createLspToolOutput(
-            formatLspToolValue({
-              results: readOperationValue(result),
-              warnings: result.failures.map(({ message }) => message),
-            }),
-            operationDetails(parameters.operation, readOperationOutcomes(result)),
+        case "inlay_hints":
+          return readOutput(
+            parameters.operation,
+            executeInlayHints(dependencies, parameters, context, signal),
             dependencies,
           );
-        }
         case "format_document":
         case "format_range":
         case "format_on_type":