@mrclrchtr/supi-lsp 6.0.1 → 6.2.0

package/src/session/scanner.ts

@@ -1,15 +1,19 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { dedupeTopmostRoots, walkProject } from "@mrclrchtr/supi-core/project";
+import { dedupeTopmostRoots } from "@mrclrchtr/supi-core/project";
 import type {
   DetectedProjectServer,
   LspConfig,
   MissingServer,
-  ProjectServerInfo,
   ServerConfig,
 } from "../config/types.ts";
 import type { LspManager } from "../manager/manager.ts";
 import { commandExists } from "../utils.ts";
+import {
+  type AutomaticLspPathPolicy,
+  createDefaultAutomaticLspPathPolicy,
+  walkAutomaticLspTree,
+} from "../workspace-path-policy.ts";
 
 const DEFAULT_MAX_DEPTH = 3;
 
@@ -17,8 +21,14 @@ export function scanProjectCapabilities(
   config: LspConfig,
   cwd: string,
   maxDepth: number = DEFAULT_MAX_DEPTH,
+  policy: AutomaticLspPathPolicy = createDefaultAutomaticLspPathPolicy(cwd),
 ): DetectedProjectServer[] {
-  const { markerMatches, extensionBasedServers } = collectServerHints(config, cwd, maxDepth);
+  const { markerMatches, extensionBasedServers } = collectServerHints(
+    config,
+    cwd,
+    maxDepth,
+    policy,
+  );
 
   return Object.entries(config.servers)
     .flatMap(([serverName, server]) => {
@@ -45,11 +55,12 @@ function collectServerHints(
   config: LspConfig,
   cwd: string,
   maxDepth: number,
+  policy: AutomaticLspPathPolicy,
 ): { markerMatches: Map<string, Set<string>>; extensionBasedServers: Set<string> } {
   const ctx: HintContext = { markerMatches: new Map(), extensionBasedServers: new Set() };
 
-  walkProject(cwd, maxDepth, (directory, entryNames) => {
-    inspectDirectory(directory, entryNames, config.servers, ctx);
+  walkAutomaticLspTree(policy, cwd, maxDepth, (directory, entries) => {
+    inspectDirectory(directory, new Set(entries.map((entry) => entry.name)), config.servers, ctx);
   });
 
   return { markerMatches: ctx.markerMatches, extensionBasedServers: ctx.extensionBasedServers };
@@ -103,15 +114,10 @@ function hasMatchingFile(directory: string, entryNames: Set<string>, fileTypes:
 export async function startDetectedServers(
   manager: LspManager,
   detected: DetectedProjectServer[],
+  policy: AutomaticLspPathPolicy = createDefaultAutomaticLspPathPolicy(manager.getCwd()),
 ): Promise<void> {
-  await Promise.all(detected.map((entry) => manager.startServerForRoot(entry.name, entry.root)));
-}
-
-export function introspectCapabilities(
-  manager: LspManager,
-  detected: DetectedProjectServer[],
-): ProjectServerInfo[] {
-  return manager.getKnownProjectServers(detected);
+  const eligible = detected.filter((entry) => policy.isEligible(entry.root, "directory"));
+  await Promise.all(eligible.map((entry) => manager.startServerForRoot(entry.name, entry.root)));
 }
 
 /**
@@ -123,17 +129,14 @@ export function scanMissingServers(
   config: LspConfig,
   cwd: string,
   maxDepth: number = DEFAULT_MAX_DEPTH,
+  policy: AutomaticLspPathPolicy = createDefaultAutomaticLspPathPolicy(cwd),
 ): MissingServer[] {
   const foundExtensions = new Set<string>();
 
-  walkProject(cwd, maxDepth, (directory, entryNames) => {
-    for (const name of entryNames) {
-      try {
-        if (!fs.statSync(path.join(directory, name)).isFile()) continue;
-      } catch {
-        continue;
-      }
-      const ext = path.extname(name).slice(1).toLowerCase();
+  walkAutomaticLspTree(policy, cwd, maxDepth, (_directory, entries) => {
+    for (const entry of entries) {
+      if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+      const ext = path.extname(entry.name).slice(1).toLowerCase();
       if (ext) foundExtensions.add(ext);
     }
   });

package/src/session/workspace-lsp-runtime.ts

@@ -13,7 +13,12 @@ import type {
   WorkspaceEdit,
   WorkspaceSymbol,
 } from "../config/types.ts";
+import type {
+  WorkspaceSentinelScanOptions,
+  WorkspaceSentinelSyncResult,
+} from "../diagnostics/workspace-sentinels.ts";
 import type { WorkspaceLspDiagnosticSurface } from "./runtime-diagnostic-surface.ts";
+import type { ProcessCrashRecoverySummary } from "./runtime-diagnostics.ts";
 
 export type WorkspaceLspRuntimeState =
   | { kind: "ready"; runtime: WorkspaceLspRuntime }
@@ -23,9 +28,22 @@ export type WorkspaceLspRuntimeState =
   | { kind: "unavailable"; reason: string };
 
 export type SemanticReadinessResult =
-  | { kind: "ready" }
-  | { kind: "timeout" }
-  | { kind: "unavailable"; reason: string };
+  | {
+      kind: "ready";
+      /** Process-crash route recovery observed while establishing file readiness. */
+      processCrashRecovery?: ProcessCrashRecoverySummary;
+    }
+  | {
+      kind: "timeout";
+      /** Process-crash route recovery observed before the readiness timeout. */
+      processCrashRecovery?: ProcessCrashRecoverySummary;
+    }
+  | {
+      kind: "unavailable";
+      reason: string;
+      /** Process-crash route recovery observed before readiness became unavailable. */
+      processCrashRecovery?: ProcessCrashRecoverySummary;
+    };
 
 /** One mutation response and the exact provider roots from its semantic route. */
 export interface RoutedMutationResponse<T> {
@@ -40,8 +58,8 @@ export interface RoutedMutationResponse<T> {
  * diagnostics, and recovery without exposing clients or the mutable manager.
  * File paths can be absolute or session-cwd-relative. A leading `@` is removed to
  * match Pi's built-in path-tool convention. Positions use raw 0-based LSP coordinates.
- * Provider request control is accepted
- * as metadata only in this expansion and is not interpreted by the runtime.
+ * Request control is forwarded to the routed client and limits the caller's
+ * wait without cancelling shared route recovery.
  */
 export interface WorkspaceLspRuntime extends WorkspaceLspDiagnosticSurface {
   hover(
@@ -68,9 +86,11 @@ export interface WorkspaceLspRuntime extends WorkspaceLspDiagnosticSurface {
     filePath: string,
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<DocumentSymbol[] | SymbolInformation[]>>;
+  /** Collect symbols from routes that can contribute within the optional path scopes. */
   workspaceSymbol(
     query: string,
     control?: CodeRequestControl,
+    scopes?: readonly string[],
   ): Promise<CodeQueryResult<SymbolInformation[] | WorkspaceSymbol[]>>;
   rename(
     filePath: string,
@@ -94,7 +114,15 @@ export interface WorkspaceLspRuntime extends WorkspaceLspDiagnosticSurface {
     control?: CodeRequestControl,
   ): Promise<SemanticReadinessResult>;
   getProjectServers(): ProjectServerInfo[];
+  /** Check whether automatic LSP work can use and serve the source file. */
   isSupportedSourceFile(filePath: string): boolean;
+  /** Inventory policy-eligible workspace sentinels and optional source files. */
+  scanWorkspaceSentinels(options?: WorkspaceSentinelScanOptions): Map<string, number>;
+  /** Refresh one policy-eligible workspace sentinel and source inventory. */
+  syncWorkspaceSentinelSnapshot(
+    previous: Map<string, number>,
+    options?: WorkspaceSentinelScanOptions,
+  ): WorkspaceSentinelSyncResult;
   trackFile(filePath: string): Promise<boolean>;
   closeFile(filePath: string): void;
   pruneMissingFiles(): readonly string[];

package/src/summary.ts

@@ -3,6 +3,7 @@ import type {
   ActiveCoverageSummaryEntry,
   OutstandingDiagnosticSummaryEntry,
 } from "./manager/manager-types.ts";
+import type { AutomaticLspPathPolicy } from "./workspace-path-policy.ts";
 
 /**
  * Display form for a file path used both for human-readable LSP output and as
@@ -67,9 +68,14 @@ export function normalizeRelevantPaths(relevantPaths: string[]): string[] {
  *  - candidate has no "/" and no ".": treat as a directory name anywhere in the path
  *  - otherwise: treat as a filename and match the basename
  */
-export function isPathRelevant(filePath: string, relevantPaths: string[], cwd: string): boolean {
+export function isPathRelevant(
+  filePath: string,
+  relevantPaths: string[],
+  cwd: string,
+  policy: AutomaticLspPathPolicy,
+): boolean {
   const normalizedFilePath = normalizeRelevantPath(filePath);
-  if (shouldIgnoreLspPath(normalizedFilePath, cwd)) return false;
+  if (shouldIgnoreLspPath(normalizedFilePath, cwd, policy)) return false;
 
   return relevantPaths.some((candidate) => {
     if (normalizedFilePath === candidate) return true;
@@ -86,48 +92,21 @@ export function isPathRelevant(filePath: string, relevantPaths: string[], cwd: s
 
 import { isFileExcludedByTsconfig } from "./config/tsconfig-scope.ts";
 
-/** Check whether a file path is inside the project tree (within cwd, not node_modules/.pnpm/out-of-tree).
- *  Does NOT check tsconfig exclusion — use `shouldIgnoreLspPath` for diagnostics/guidance filtering. */
-export function isInProjectTree(filePath: string, cwd: string): boolean {
-  const normalized = normalizeRelevantPath(filePath);
-  if (
-    normalized === "node_modules" ||
-    normalized.startsWith("node_modules/") ||
-    normalized.includes("/node_modules/") ||
-    normalized === ".pnpm" ||
-    normalized.startsWith(".pnpm/") ||
-    normalized.includes("/.pnpm/")
-  ) {
-    return false;
-  }
-
-  const absolutePath = path.resolve(cwd, filePath);
-  const relativePath = path.relative(cwd, absolutePath);
-  return !(relativePath.startsWith(`..${path.sep}`) || relativePath === "..");
+/** Check whether the supplied automatic path policy allows a file path. */
+export function isInProjectTree(filePath: string, policy: AutomaticLspPathPolicy): boolean {
+  return policy.isEligible(filePath);
 }
 
-/** Check whether a file path is inside the current project (not ignored and within cwd). */
-export function isProjectSource(filePath: string, cwd: string): boolean {
-  return isInProjectTree(filePath, cwd);
-}
-
-export function shouldIgnoreLspPath(filePath: string, cwd: string): boolean {
-  if (!isInProjectTree(filePath, cwd)) return true;
+/** Check automatic and tsconfig diagnostic scope for one file path. */
+export function shouldIgnoreLspPath(
+  filePath: string,
+  cwd: string,
+  policy: AutomaticLspPathPolicy,
+): boolean {
+  if (!isInProjectTree(filePath, policy)) return true;
 
   const normalized = normalizeRelevantPath(filePath);
-  if (
-    normalized === "node_modules" ||
-    normalized.startsWith("node_modules/") ||
-    normalized.includes("/node_modules/") ||
-    normalized === ".pnpm" ||
-    normalized.startsWith(".pnpm/") ||
-    normalized.includes("/.pnpm/") ||
-    isFileExcludedByTsconfig(normalized, cwd)
-  ) {
-    return true;
-  }
-
-  return false;
+  return isFileExcludedByTsconfig(normalized, cwd);
 }
 
 function normalizeRelevantPath(filePath: string): string {

package/src/utils.ts

@@ -3,12 +3,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 
-export {
-  fileToUri,
-  resolveToolPath as resolveSessionPath,
-  uriToFile,
-} from "@mrclrchtr/supi-core/path";
-
 // ── Language ID Detection ─────────────────────────────────────────────
 
 const EXT_TO_LANGUAGE: Record<string, string> = {
@@ -68,11 +62,6 @@ export function detectLanguageId(filePath: string): string {
   return EXT_TO_LANGUAGE[ext] ?? ext;
 }
 
-/** Get the file extension (without dot) from a file path. */
-export function getFileExtension(filePath: string): string {
-  return path.extname(filePath).slice(1).toLowerCase();
-}
-
 // ── PATH Validation ───────────────────────────────────────────────────
 
 /**
@@ -80,9 +69,9 @@ export function getFileExtension(filePath: string): string {
  * Uses synchronous check to avoid complexity.
  */
 export function commandExists(command: string): boolean {
-  // If it's an absolute path, check directly
+  // If it is an absolute path, validate the exact executable file.
   if (path.isAbsolute(command)) {
-    return fs.existsSync(command);
+    return isExecutableFile(command);
   }
 
   const pathDirs = (process.env.PATH ?? "").split(path.delimiter);
@@ -92,13 +81,18 @@ export function commandExists(command: string): boolean {
   for (const dir of pathDirs) {
     for (const ext of extensions) {
       const fullPath = path.join(dir, command + ext);
-      try {
-        fs.accessSync(fullPath, fs.constants.X_OK);
-        return true;
-      } catch {
-        // Not found here, continue
-      }
+      if (isExecutableFile(fullPath)) return true;
     }
   }
   return false;
 }
+
+function isExecutableFile(filePath: string): boolean {
+  try {
+    if (!fs.statSync(filePath).isFile()) return false;
+    fs.accessSync(filePath, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/workspace-path-policy.ts

@@ -0,0 +1,287 @@
+import { type Dirent, lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import * as path from "node:path";
+import ignore from "ignore";
+import { loadLspSettings } from "./config/lsp-settings.ts";
+
+/** Directory names that automatic LSP work never enters or selects. */
+export const AUTOMATIC_LSP_EXCLUDED_DIRECTORIES: readonly string[] = Object.freeze([
+  ".git",
+  ".cache",
+  ".pi",
+  ".pnpm",
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  "__pycache__",
+]);
+
+const BUILT_IN_EXCLUSIONS = new Set(AUTOMATIC_LSP_EXCLUDED_DIRECTORIES);
+
+/** Automatic path rules for one Workspace LSP runtime. The rules do not change. */
+export interface AutomaticLspPathPolicy {
+  /** Canonical absolute workspace root used for all matching. */
+  readonly workspaceRoot: string;
+  /** True when automatic LSP work can use the path. */
+  isEligible(candidate: string, kind?: "file" | "directory"): boolean;
+}
+
+/** Create the automatic path rules for one Workspace LSP runtime. */
+export function createAutomaticLspPathPolicy(
+  workspaceRoot: string,
+  excludePatterns: readonly string[],
+): AutomaticLspPathPolicy {
+  const canonicalRoot = canonicalPath(workspaceRoot);
+  const configuredExclusions = createIgnoreMatcher([...excludePatterns]);
+  const repositoryRules = compileRepositoryRules(canonicalRoot, configuredExclusions);
+  return Object.freeze({
+    workspaceRoot: canonicalRoot,
+    isEligible(candidate: string, kind: "file" | "directory" = "file"): boolean {
+      const relativePath = normalizeCandidate(canonicalRoot, workspaceRoot, candidate);
+      if (
+        relativePath === null ||
+        !isAutomaticCandidateAllowed(workspaceRoot, relativePath, kind)
+      ) {
+        return false;
+      }
+      return isEligibleRelativePath(
+        relativePath,
+        kind === "directory",
+        configuredExclusions,
+        repositoryRules,
+      );
+    },
+  });
+}
+
+/**
+ * Create path rules for an automatic LSP helper used outside a runtime.
+ * Runtime-owned operations should pass the rules created at startup instead.
+ */
+export function createDefaultAutomaticLspPathPolicy(workspaceRoot: string): AutomaticLspPathPolicy {
+  return createAutomaticLspPathPolicy(workspaceRoot, loadLspSettings(workspaceRoot).exclude);
+}
+
+/**
+ * Walk paths allowed by the policy without visiting symbolic-link directories.
+ *
+ * The visitor receives only entries that the automatic LSP policy allows.
+ * Return `true` from the visitor to stop the walk after that directory.
+ */
+export function walkAutomaticLspTree(
+  policy: AutomaticLspPathPolicy,
+  directory: string,
+  depth: number,
+  onDirectory: (directory: string, entries: readonly Dirent[]) => boolean | undefined,
+): void {
+  walkDirectoryTree({
+    directory,
+    depth,
+    includeEntry: (candidate, entry) =>
+      policy.isEligible(candidate, entry.isDirectory() ? "directory" : "file"),
+    onDirectory,
+  });
+}
+
+interface DirectoryWalkOptions {
+  directory: string;
+  depth: number;
+  includeEntry: (candidate: string, entry: Dirent) => boolean;
+  onDirectory: (directory: string, entries: readonly Dirent[]) => boolean | undefined;
+  beforeFilter?: (directory: string) => void;
+}
+
+function walkDirectoryTree(options: DirectoryWalkOptions): boolean {
+  const { directory, depth, includeEntry, onDirectory, beforeFilter } = options;
+  beforeFilter?.(directory);
+  let entries: Dirent[];
+  try {
+    entries = [...readdirSync(directory, { withFileTypes: true })].sort((a, b) =>
+      a.name.localeCompare(b.name),
+    );
+  } catch {
+    return false;
+  }
+
+  const eligibleEntries = entries.filter((entry) =>
+    includeEntry(path.join(directory, entry.name), entry),
+  );
+  if (onDirectory(directory, eligibleEntries) === true) return true;
+  if (depth <= 0) return false;
+
+  for (const entry of eligibleEntries) {
+    if (!entry.isDirectory()) continue;
+    if (
+      walkDirectoryTree({
+        ...options,
+        directory: path.join(directory, entry.name),
+        depth: depth - 1,
+      })
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+type IgnoreMatcher = ReturnType<typeof ignore>;
+
+function createIgnoreMatcher(patterns: string | readonly string[]): IgnoreMatcher {
+  return ignore({ ignorecase: false }).add(patterns);
+}
+
+interface RepositoryIgnoreRules {
+  readonly base: string;
+  readonly matcher: IgnoreMatcher;
+}
+
+function compileRepositoryRules(
+  workspaceRoot: string,
+  configuredExclusions: IgnoreMatcher,
+): readonly RepositoryIgnoreRules[] {
+  const rules: RepositoryIgnoreRules[] = [];
+
+  walkDirectoryTree({
+    directory: workspaceRoot,
+    depth: Number.MAX_SAFE_INTEGER,
+    includeEntry: (candidate, entry) => {
+      if (entry.isSymbolicLink() || !entry.isDirectory()) return false;
+      const relativePath = path.relative(workspaceRoot, candidate).split(path.sep).join("/");
+      return isEligibleRelativePath(relativePath, true, configuredExclusions, rules);
+    },
+    onDirectory: () => undefined,
+    beforeFilter: (directory) => {
+      const relativeDirectory = path.relative(workspaceRoot, directory).split(path.sep).join("/");
+      const nestedRules = readRepositoryIgnore(directory, relativeDirectory);
+      if (nestedRules) rules.push(nestedRules);
+    },
+  });
+
+  return Object.freeze([...rules]);
+}
+
+function readRepositoryIgnore(
+  directory: string,
+  relativeDirectory: string,
+): RepositoryIgnoreRules | null {
+  try {
+    const matcher = createIgnoreMatcher(readFileSync(path.join(directory, ".gitignore"), "utf-8"));
+    return Object.freeze({ base: relativeDirectory, matcher });
+  } catch {
+    return null;
+  }
+}
+
+function isEligibleRelativePath(
+  relativePath: string,
+  directory: boolean,
+  configuredExclusions: IgnoreMatcher,
+  repositoryRules: readonly RepositoryIgnoreRules[],
+): boolean {
+  const segments = relativePath.split("/");
+  if (
+    segments.some(
+      (segment, index) =>
+        BUILT_IN_EXCLUSIONS.has(segment) && (directory || index < segments.length - 1),
+    )
+  ) {
+    return false;
+  }
+  if (relativePath === "") return true;
+
+  const matchPath = directory ? `${relativePath}/` : relativePath;
+  if (configuredExclusions.ignores(matchPath)) return false;
+  return !isRepositoryIgnored(relativePath, directory, repositoryRules);
+}
+
+function isRepositoryIgnored(
+  relativePath: string,
+  directory: boolean,
+  repositoryRules: readonly RepositoryIgnoreRules[],
+): boolean {
+  let ignored = false;
+  for (const rules of repositoryRules) {
+    const localPath = relativeToRuleBase(rules.base, relativePath);
+    if (localPath === null || localPath === "") continue;
+    const result = rules.matcher.test(directory ? `${localPath}/` : localPath);
+    if (result.ignored) ignored = true;
+    else if (result.unignored) ignored = false;
+  }
+  return ignored;
+}
+
+function relativeToRuleBase(base: string, relativePath: string): string | null {
+  if (base === "") return relativePath;
+  if (relativePath === base) return "";
+  return relativePath.startsWith(`${base}/`) ? relativePath.slice(base.length + 1) : null;
+}
+
+function isAutomaticCandidateAllowed(
+  suppliedRoot: string,
+  relativePath: string,
+  kind: "file" | "directory",
+): boolean {
+  if (relativePath === "") return true;
+  let current = path.resolve(suppliedRoot);
+  const segments = relativePath.split("/");
+
+  for (const [index, segment] of segments.entries()) {
+    current = path.join(current, segment);
+    let link: ReturnType<typeof lstatSync>;
+    try {
+      link = lstatSync(current);
+    } catch {
+      return true;
+    }
+    if (!link.isSymbolicLink()) continue;
+    if (index < segments.length - 1) return false;
+
+    try {
+      const target = statSync(current);
+      return kind === "file" && target.isFile();
+    } catch {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function canonicalPath(candidate: string): string {
+  try {
+    return realpathSync(candidate);
+  } catch {
+    return path.resolve(candidate);
+  }
+}
+
+function normalizeCandidate(
+  canonicalRoot: string,
+  suppliedRoot: string,
+  candidate: string,
+): string | null {
+  const absoluteCandidate = path.isAbsolute(candidate)
+    ? mapSuppliedRootToCanonical(canonicalRoot, suppliedRoot, candidate)
+    : path.resolve(canonicalRoot, candidate);
+  const relativePath = path.relative(canonicalRoot, absoluteCandidate);
+  if (relativePath === "") return "";
+  if (relativePath === ".." || relativePath.startsWith(`..${path.sep}`)) return null;
+  return relativePath.split(path.sep).join("/");
+}
+
+function mapSuppliedRootToCanonical(
+  canonicalRoot: string,
+  suppliedRoot: string,
+  candidate: string,
+): string {
+  const resolvedSuppliedRoot = path.resolve(suppliedRoot);
+  const relativePath = path.relative(resolvedSuppliedRoot, path.resolve(candidate));
+  if (relativePath === "" || (relativePath !== ".." && !relativePath.startsWith(`..${path.sep}`))) {
+    return path.resolve(canonicalRoot, relativePath);
+  }
+  return path.resolve(candidate);
+}

package/src/config/server-actions.ts

@@ -1,59 +0,0 @@
-// Server capability action label helpers — maps LSP capabilities to readable action labels.
-
-import type { ServerCapabilities } from "../config/types.ts";
-
-interface LspServerSupportedActionSpec {
-  label: string;
-  isSupported: (capabilities: ServerCapabilities | null | undefined) => boolean;
-}
-
-const LSP_SERVER_SUPPORTED_ACTION_SPECS: readonly LspServerSupportedActionSpec[] = [
-  {
-    label: "diagnostics [optional file]",
-    isSupported: () => true,
-  },
-  {
-    label: "hover(file,line,char)",
-    isSupported: (capabilities) => Boolean(capabilities?.hoverProvider),
-  },
-  {
-    label: "definition(file,line,char)",
-    isSupported: (capabilities) => Boolean(capabilities?.definitionProvider),
-  },
-  {
-    label: "references(file,line,char)",
-    isSupported: (capabilities) => Boolean(capabilities?.referencesProvider),
-  },
-  {
-    label: "implementation(file,line,char)",
-    isSupported: (capabilities) => Boolean(capabilities?.implementationProvider),
-  },
-  {
-    label: "symbols(file)",
-    isSupported: (capabilities) => Boolean(capabilities?.documentSymbolProvider),
-  },
-  {
-    label: "workspace_symbols(query)",
-    isSupported: (capabilities) => Boolean(capabilities?.workspaceSymbolProvider),
-  },
-  {
-    label: "rename(file,line,char,newName)",
-    isSupported: (capabilities) => Boolean(capabilities?.renameProvider),
-  },
-  {
-    label: "code_actions(file,line,char)",
-    isSupported: (capabilities) => Boolean(capabilities?.codeActionProvider),
-  },
-] as const;
-
-/**
- * Get the list of supported LSP server actions based on capabilities.
- */
-export function getSupportedLspServerActions(
-  capabilities: ServerCapabilities | null | undefined,
-): string[] {
-  if (!capabilities) return [];
-  return LSP_SERVER_SUPPORTED_ACTION_SPECS.filter((spec) => spec.isSupported(capabilities)).map(
-    (spec) => spec.label,
-  );
-}

package/src/pattern-matcher.ts

@@ -1,24 +0,0 @@
-import ignore from "ignore";
-
-/** Gitignore-style glob pattern matching for path exclusion.
- *
- * Delegates to the {@link https://github.com/kaelzhang/node-ignore | ignore} package,
- * which provides battle-tested .gitignore semantics used by ESLint, Prettier, and others.
- *
- * Supports full gitignore syntax: literal names, `*` / `?` wildcards, `**` recursive globs,
- * leading `/` anchored patterns, trailing `/` directory-only patterns, and `!` negation.
- *
- * **Note:** Patterns that start with `#` are treated as comments unless escaped with `\#`.
- */
-
-/**
- * Check whether a project-relative file path matches a gitignore-style glob pattern.
- *
- * @param filePath - Relative file path with forward slashes (e.g. `"src/__tests__/bar.test.ts"`)
- * @param pattern - Gitignore-style glob pattern (e.g. `"__tests__/"`, `"*.test.ts"`, `"/build"`)
- * @returns `true` if the file path matches the pattern
- */
-export function isGlobMatch(filePath: string, pattern: string): boolean {
-  if (!filePath || !pattern) return false;
-  return ignore().add(pattern).ignores(filePath);
-}