@ian-pascoe/pi-lsp 0.1.0 → 0.1.1

package/README.md

@@ -45,6 +45,7 @@ Pi LSP reads only the `lsp` key from Pi's global `settings.json` and trusted pro
             "languageId": "typescriptreact"
           }
         ],
+        "requireRootMarker": true,
         "rootMarkers": ["tsconfig.json", "package.json", ".git"],
         "initializationOptions": {},
         "settings": {},
@@ -58,14 +59,18 @@ Pi LSP reads only the `lsp` key from Pi's global `settings.json` and trusted pro
 Every field is optional except an enabled server's non-empty `command` and `languages`. Each
 language needs a non-empty `languageId` and at least one extension or exact filename. Extensions
 include their leading period. `rootMarkers` are basename glob patterns; the nearest matching
-ancestor becomes the server root and Pi's working directory is the fallback.
+ancestor becomes the server root and Pi's working directory is the fallback. Set
+`requireRootMarker` to `true` to exclude the server for files without any matching ancestor; it
+defaults to `false`. A required empty `rootMarkers` list is invalid. Explicit requests naming an
+otherwise compatible excluded server report that its required root marker was not found.
 
 Global and project timeouts merge by field. A project server replaces the complete global server
 with the same ID; set a project server to `null` to remove it. `initializationOptions` is sent only
 during initialization. `settings` is used for `workspace/didChangeConfiguration` and
 `workspace/configuration`. Environment strings override `process.env`; `null` removes a variable.
-A malformed layer or unknown field disables LSP startup and remains visible through `status`.
-Untrusted project settings are ignored.
+Invalid server definitions and timeout fields are quarantined individually and remain visible
+through `status`; unrelated valid settings continue to work. An invalid project server replacement
+still shadows the global definition. Untrusted project settings are ignored.
 
 Pi's `/reload` reloads configuration. Servers start on first use, live for one Pi session, and stay
 unavailable after a process or protocol failure until `restart` or `/reload`.
@@ -164,6 +169,9 @@ Changed, created, and renamed destination files are diagnosed; deleted files are
 recognized result gets an explicit outcome, including `no diagnostics`, `no configured server`,
 timeout, unavailable server, or an `apply_patch` adapter-version warning. Diagnostics preserve
 duplicates from independent servers and never change the original tool's success or error state.
+Only servers that advertise document diagnostics participate; formatting-only servers remain
+available for explicit LSP formatting operations without appearing in Post-edit Diagnostics.
+Files excluded by every matching server's Activation Gate are skipped silently.
 
 Findings, matched-server failures, timeouts, and adapter warnings also appear in one expandable
 Post-edit Diagnostics Entry after the current tool batch. Clean results and files without a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ian-pascoe/pi-lsp",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "private": false,
   "description": "Configured language-server tools and post-edit diagnostics for Pi",
   "keywords": [
@@ -30,10 +30,6 @@
     "access": "public",
     "provenance": true
   },
-  "scripts": {
-    "test": "vitest run --config ../../vitest.config.ts --root .",
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
   "dependencies": {
     "cross-spawn": "^7.0.6",
     "vscode-languageserver-protocol": "^3.17.5"
@@ -53,5 +49,9 @@
     "extensions": [
       "./src/index.ts"
     ]
+  },
+  "scripts": {
+    "test": "vitest run --config ../../vitest.config.ts --root .",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
   }
-}
+}

package/src/lsp-post-edit-diagnostics.ts

@@ -273,6 +273,7 @@ export async function appendPostEditDiagnostics(
     })),
     ...(await diagnostics.runPostEditDiagnostics(extracted.paths)),
   ];
+  if (outcomes.length === 0) return undefined;
   const patch: PostEditDiagnosticsResultPatch = {
     content: [...event.content, { type: "text", text: formatPostEditDiagnostics(outcomes) }],
     details: event.details,

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. */
@@ -167,8 +170,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 +184,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 +202,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,
     });
   }
 
@@ -288,12 +301,21 @@ export class LspServerManager<TClient extends LspManagedServerClient = LspManage
     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);
   }
 
+  /** 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 every matching capable instance while retaining independent successes and failures. */
   async runRead<T>(
     filePath: string,
@@ -446,10 +468,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/pi-lsp-extension.ts

@@ -14,7 +14,11 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
-import { PositionEncodingKind, type Diagnostic } from "vscode-languageserver-protocol/node";
+import {
+  DocumentDiagnosticRequest,
+  PositionEncodingKind,
+  type Diagnostic,
+} from "vscode-languageserver-protocol/node";
 import {
   appendPiPostEditDiagnostics,
   type PostEditDiagnosticOutcome,
@@ -154,7 +158,7 @@ class ManagerPostEditDiagnosticsRunner implements PostEditDiagnosticsRunner {
       const result = await this.session.manager.runRead(
         filePath,
         undefined,
-        () => true,
+        (client) => client.hasCapability(DocumentDiagnosticRequest.method),
         async (client, route): Promise<readonly PostEditDiagnosticOutcome[]> => {
           const diagnostics = await client.documentDiagnostics(
             filePath,
@@ -185,7 +189,13 @@ class ManagerPostEditDiagnosticsRunner implements PostEditDiagnosticsRunner {
       const successfulOutcomes = result.successes.flatMap(({ value }) => value);
       outcomes.push(...successfulOutcomes);
       outcomes.push(
-        ...result.failures.map((failure) => failureDiagnosticOutcome(filePath, failure)),
+        ...result.failures.flatMap((failure) =>
+          failure.code === "no-capable-server" ||
+          (failure.code === "no-matching-server" &&
+            this.session.manager.hasConfiguredLanguageServerForFile(filePath))
+            ? []
+            : [failureDiagnosticOutcome(filePath, failure)],
+        ),
       );
     }
     return outcomes;

package/src/pi-lsp-settings.ts

@@ -12,6 +12,7 @@ const DEFAULT_LSP_TIMEOUTS = {
 const NonEmptyStringSchema = Type.String({ minLength: 1 });
 const PositiveMillisecondsSchema = Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER });
 const JsonValueSchema = Type.Any();
+const JsonObjectSchema = Type.Record(Type.String(), JsonValueSchema);
 const LspLanguageMappingSchema = Type.Object(
   {
     extensions: Type.Optional(Type.Array(NonEmptyStringSchema, { minItems: 1 })),
@@ -29,6 +30,7 @@ const LspServerDefinitionSchema = Type.Object(
     ),
     initializationOptions: Type.Optional(JsonValueSchema),
     languages: Type.Optional(Type.Array(LspLanguageMappingSchema, { minItems: 1 })),
+    requireRootMarker: Type.Optional(Type.Boolean()),
     rootMarkers: Type.Optional(Type.Array(NonEmptyStringSchema)),
     settings: Type.Optional(JsonValueSchema),
   },
@@ -43,18 +45,6 @@ const LspTimeoutsSchema = Type.Object(
   },
   { additionalProperties: false },
 );
-const LspLayerSchema = Type.Object(
-  {
-    servers: Type.Optional(
-      Type.Record(
-        Type.String({ minLength: 1 }),
-        Type.Union([LspServerDefinitionSchema, Type.Null()]),
-      ),
-    ),
-    timeouts: Type.Optional(LspTimeoutsSchema),
-  },
-  { additionalProperties: false },
-);
 const SettingsDocumentSchema = Type.Object({ lsp: Type.Optional(JsonValueSchema) });
 
 interface JsonObject {
@@ -64,7 +54,16 @@ interface JsonObject {
 type JsonValue = null | boolean | number | string | readonly JsonValue[] | JsonObject;
 type LspServerDefinitionWire = Static<typeof LspServerDefinitionSchema>;
 type LspTimeoutsWire = Static<typeof LspTimeoutsSchema>;
-type LspLayerWire = Static<typeof LspLayerSchema>;
+type LspTimeoutName = keyof typeof DEFAULT_LSP_TIMEOUTS;
+const LSP_TIMEOUT_NAMES: readonly LspTimeoutName[] = [
+  "diagnosticsMs",
+  "initializeMs",
+  "requestMs",
+  "shutdownMs",
+];
+type ParsedLspServerDefinition =
+  | { readonly kind: "excluded" }
+  | { readonly kind: "valid"; readonly value: LspServerDefinitionWire };
 
 /** Describes one configured filename or extension mapping to an LSP language identifier. */
 export interface LspLanguageMapping {
@@ -73,7 +72,7 @@ export interface LspLanguageMapping {
   readonly languageId: string;
 }
 
-/** Contains the parsed command and protocol values for one enabled language server. */
+/** Contains the parsed command and protocol values for one configured language server. */
 export interface LspServerDefinition {
   readonly args: readonly string[];
   readonly command: string;
@@ -81,6 +80,8 @@ export interface LspServerDefinition {
   readonly id: string;
   readonly initializationOptions?: JsonValue;
   readonly languages: readonly LspLanguageMapping[];
+  /** Require any root marker above a candidate file; false falls back to Pi's working directory. */
+  readonly requireRootMarker: boolean;
   readonly rootMarkers: readonly string[];
   readonly settings?: JsonValue;
 }
@@ -93,7 +94,7 @@ export interface LspTimeouts {
   readonly shutdownMs: number;
 }
 
-/** Reports resolved trusted configuration, or disabled startup when either layer is malformed. */
+/** Reports resolved trusted configuration, retaining valid entries when other settings are invalid. */
 export interface ResolvedLspSettings {
   readonly enabled: boolean;
   readonly servers: ReadonlyMap<string, LspServerDefinition>;
@@ -113,58 +114,150 @@ type PiSettingsDocument = ReturnType<SettingsManager["getGlobalSettings"]>;
 /** Pi's core Settings type or a test/boundary document carrying the extension-owned `lsp` value. */
 export type LspSettingsDocumentInput = PiSettingsDocument | { readonly lsp?: JsonValue };
 
-type ParsedLspLayer =
-  | { readonly kind: "absent" }
-  | { readonly kind: "invalid"; readonly warning: string }
-  | { readonly kind: "valid"; readonly value: LspLayerWire };
+interface ParsedLspLayer {
+  readonly servers: ReadonlyMap<string, ParsedLspServerDefinition>;
+  readonly timeouts: LspTimeoutsWire;
+  readonly warnings: readonly string[];
+}
+
+function isJsonObject(value: JsonValue): value is JsonObject {
+  return Value.Check(JsonObjectSchema, value);
+}
 
-function lspValidationWarning(value: JsonValue, scope: "global" | "project"): string {
-  const error = Value.Errors(LspLayerSchema, value)[0];
+function schemaValidationWarning(
+  schema: typeof LspServerDefinitionSchema | typeof PositiveMillisecondsSchema,
+  value: JsonValue,
+  prefix: string,
+): string {
+  const error = Value.Errors(schema, value)[0];
   const path = error?.instancePath.replaceAll("/", ".") ?? "";
   const unknownField =
     error?.keyword === "additionalProperties" ? error.params.additionalProperties[0] : undefined;
-  return `${scope} lsp${path}${unknownField === undefined ? "" : `.${unknownField}`}: ${error?.message ?? "invalid settings"}`;
+  const unknownFieldSuffix = unknownField === undefined ? "" : `.${String(unknownField)}`;
+  return `${prefix}${path}${unknownFieldSuffix}: ${error?.message ?? "invalid settings"}`;
 }
 
-function readLspLayer(
-  settings: LspSettingsDocumentInput,
+function parseLspServerDefinitions(
+  value: JsonValue | undefined,
   scope: "global" | "project",
-): ParsedLspLayer {
-  if (!Value.Check(SettingsDocumentSchema, settings)) {
-    return { kind: "invalid", warning: `${scope} settings: expected a JSON object` };
-  }
-  if (settings.lsp === undefined) return { kind: "absent" };
-  if (!Value.Check(LspLayerSchema, settings.lsp)) {
-    return { kind: "invalid", warning: lspValidationWarning(settings.lsp, scope) };
+): Pick<ParsedLspLayer, "servers" | "warnings"> {
+  const warnings: string[] = [];
+  const servers = new Map<string, ParsedLspServerDefinition>();
+  if (value === undefined) return { servers, warnings };
+  if (!isJsonObject(value)) {
+    return { servers, warnings: [`${scope} lsp.servers: expected a JSON object`] };
   }
-  for (const [serverId, server] of Object.entries(settings.lsp.servers ?? {})) {
-    if (server === null) continue;
+  for (const [id, server] of Object.entries(value)) {
+    if (!Value.Check(NonEmptyStringSchema, id)) {
+      warnings.push(`${scope} lsp.servers.${String(id)}: server ID must be a non-empty string`);
+      continue;
+    }
+    if (server === null) {
+      servers.set(id, { kind: "excluded" });
+      continue;
+    }
+    if (!Value.Check(LspServerDefinitionSchema, server)) {
+      warnings.push(
+        schemaValidationWarning(LspServerDefinitionSchema, server, `${scope} lsp.servers.${id}`),
+      );
+      servers.set(id, { kind: "excluded" });
+      continue;
+    }
     if (server.command === undefined || server.languages === undefined) {
-      return {
-        kind: "invalid",
-        warning: `${scope} lsp.servers.${serverId}: command and languages are required`,
-      };
+      warnings.push(`${scope} lsp.servers.${id}: command and languages are required`);
+      servers.set(id, { kind: "excluded" });
+      continue;
     }
     if (
       server.languages.some(
         (language) => language.extensions === undefined && language.fileNames === undefined,
       )
     ) {
-      return {
-        kind: "invalid",
-        warning: `${scope} lsp.servers.${serverId}.languages: each language needs extensions or fileNames`,
-      };
+      warnings.push(
+        `${scope} lsp.servers.${id}.languages: each language needs extensions or fileNames`,
+      );
+      servers.set(id, { kind: "excluded" });
+      continue;
+    }
+    if (server.requireRootMarker === true && (server.rootMarkers?.length ?? 0) === 0) {
+      warnings.push(
+        `${scope} lsp.servers.${id}.rootMarkers: at least one root marker is required when requireRootMarker is true`,
+      );
+      servers.set(id, { kind: "excluded" });
+      continue;
+    }
+    servers.set(id, { kind: "valid", value: server });
+  }
+  return { servers, warnings };
+}
+
+function isLspTimeoutName(name: string): name is LspTimeoutName {
+  return LSP_TIMEOUT_NAMES.some((timeoutName) => timeoutName === name);
+}
+
+function parseLspTimeouts(
+  value: JsonValue | undefined,
+  scope: "global" | "project",
+): Pick<ParsedLspLayer, "timeouts" | "warnings"> {
+  const warnings: string[] = [];
+  const timeouts: LspTimeoutsWire = {};
+  if (value === undefined) return { timeouts, warnings };
+  if (!isJsonObject(value)) {
+    return { timeouts, warnings: [`${scope} lsp.timeouts: expected a JSON object`] };
+  }
+  for (const [name, timeout] of Object.entries(value)) {
+    if (!isLspTimeoutName(name)) {
+      warnings.push(`${scope} lsp.timeouts.${name}: unknown field`);
+      continue;
     }
+    if (!Value.Check(PositiveMillisecondsSchema, timeout)) {
+      warnings.push(
+        schemaValidationWarning(
+          PositiveMillisecondsSchema,
+          timeout,
+          `${scope} lsp.timeouts.${name}`,
+        ),
+      );
+      continue;
+    }
+    timeouts[name] = timeout;
   }
-  return { kind: "valid", value: settings.lsp };
+  return { timeouts, warnings };
+}
+
+function readLspLayer(
+  settings: LspSettingsDocumentInput,
+  scope: "global" | "project",
+): ParsedLspLayer {
+  if (!Value.Check(SettingsDocumentSchema, settings)) {
+    return {
+      servers: new Map(),
+      timeouts: {},
+      warnings: [`${scope} settings: expected a JSON object`],
+    };
+  }
+  if (settings.lsp === undefined) return { servers: new Map(), timeouts: {}, warnings: [] };
+  if (!isJsonObject(settings.lsp)) {
+    return {
+      servers: new Map(),
+      timeouts: {},
+      warnings: [`${scope} lsp: expected a JSON object`],
+    };
+  }
+  const warnings = Object.keys(settings.lsp)
+    .filter((field) => field !== "servers" && field !== "timeouts")
+    .map((field) => `${scope} lsp.${field}: unknown field`);
+  const parsedServers = parseLspServerDefinitions(settings.lsp.servers, scope);
+  const parsedTimeouts = parseLspTimeouts(settings.lsp.timeouts, scope);
+  return {
+    servers: parsedServers.servers,
+    timeouts: parsedTimeouts.timeouts,
+    warnings: [...warnings, ...parsedServers.warnings, ...parsedTimeouts.warnings],
+  };
 }
 
 function mergeLspTimeouts(globalLayer: ParsedLspLayer, projectLayer: ParsedLspLayer): LspTimeouts {
-  const timeoutValues: readonly (LspTimeoutsWire | undefined)[] = [
-    globalLayer.kind === "valid" ? globalLayer.value.timeouts : undefined,
-    projectLayer.kind === "valid" ? projectLayer.value.timeouts : undefined,
-  ];
-  return Object.assign({}, DEFAULT_LSP_TIMEOUTS, ...timeoutValues);
+  return Object.assign({}, DEFAULT_LSP_TIMEOUTS, globalLayer.timeouts, projectLayer.timeouts);
 }
 
 function resolveLspEnvironment(
@@ -199,6 +292,7 @@ function resolveLspServerDefinition(
     environment: resolveLspEnvironment(server.environment),
     id,
     languages,
+    requireRootMarker: server.requireRootMarker ?? false,
     rootMarkers: server.rootMarkers ?? [],
   };
   const initializationOptions = server.initializationOptions;
@@ -224,18 +318,13 @@ function mergeLspServers(
   projectLayer: ParsedLspLayer,
 ): ReadonlyMap<string, LspServerDefinition> {
   const serverDefinitions = new Map<string, LspServerDefinitionWire>();
-  const addServers = (layer: ParsedLspLayer, projectLayerValue: boolean): void => {
-    if (layer.kind !== "valid") return;
-    for (const [id, server] of Object.entries(layer.value.servers ?? {})) {
-      if (server === null) {
-        if (projectLayerValue) serverDefinitions.delete(id);
-        continue;
-      }
-      serverDefinitions.set(id, server);
-    }
-  };
-  addServers(globalLayer, false);
-  addServers(projectLayer, true);
+  for (const [id, server] of globalLayer.servers) {
+    if (server.kind === "valid") serverDefinitions.set(id, server.value);
+  }
+  for (const [id, server] of projectLayer.servers) {
+    serverDefinitions.delete(id);
+    if (server.kind === "valid") serverDefinitions.set(id, server.value);
+  }
   return new Map(
     [...serverDefinitions]
       .sort(([left], [right]) => left.localeCompare(right))
@@ -243,21 +332,14 @@ function mergeLspServers(
   );
 }
 
-/** Resolve global and trusted-project LSP settings without adding an `lsp` field to Pi's Settings type. */
+/** Resolve global and trusted-project LSP settings, quarantining invalid entries instead of disabling valid settings. */
 export function resolveLspSettings(reader: LspSettingsReader): ResolvedLspSettings {
   const globalLayer = readLspLayer(reader.getGlobalSettings(), "global");
   const projectLayer = readLspLayer(reader.getProjectSettings(), "project");
-  const warnings = [globalLayer, projectLayer]
-    .filter(
-      (layer): layer is Extract<ParsedLspLayer, { readonly kind: "invalid" }> =>
-        layer.kind === "invalid",
-    )
-    .map((layer) => layer.warning);
-  const enabled = warnings.length === 0;
   return {
-    enabled,
-    servers: enabled ? mergeLspServers(globalLayer, projectLayer) : new Map(),
+    enabled: true,
+    servers: mergeLspServers(globalLayer, projectLayer),
     timeouts: mergeLspTimeouts(globalLayer, projectLayer),
-    warnings,
+    warnings: [...globalLayer.warnings, ...projectLayer.warnings],
   };
 }