@mrclrchtr/supi-lsp 1.3.1 → 1.5.0

package/src/client/client.ts

@@ -4,7 +4,8 @@
 // biome-ignore lint/nursery/noExcessiveLinesPerFile: LspClient remains a cohesive stateful wrapper; refresh logic is already split out.
 import { type ChildProcess, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { CLIENT_CAPABILITIES } from "../capabilities.ts";
+import * as path from "node:path";
+import { CLIENT_CAPABILITIES } from "../config/capabilities.ts";
 import type {
   CodeAction,
   CodeActionContext,
@@ -27,9 +28,9 @@ import type {
   VersionedTextDocumentIdentifier,
   WorkspaceEdit,
   WorkspaceSymbol,
-} from "../types.ts";
+} from "../config/types.ts";
 import { detectLanguageId, fileToUri, uriToFile } from "../utils.ts";
-import { JsonRpcClient } from "./transport.ts";
+import { JsonRpcClient, JsonRpcRequestError } from "./transport.ts";
 
 const SHUTDOWN_TIMEOUT_MS = 5_000;
 const DIAGNOSTIC_WAIT_MS = 3_000;
@@ -119,6 +120,7 @@ export class LspClient {
         this.handlePublishDiagnostics(params as PublishDiagnosticsParams);
       }
     });
+    this.rpc.onRequest((method, params) => this.handleServerRequest(method, params));
 
     // Handle crashes
     this.process.on("exit", (_code) => {
@@ -469,6 +471,28 @@ export class LspClient {
     }
   }
 
+  private handleServerRequest(method: string, params: unknown): unknown {
+    switch (method) {
+      case "workspace/configuration":
+        return this.buildWorkspaceConfigurationResult(params);
+      case "workspace/workspaceFolders":
+        return [{ uri: fileToUri(this.root), name: path.basename(this.root) || this.root }];
+      case "client/registerCapability":
+      case "client/unregisterCapability":
+      case "window/workDoneProgress/create":
+        return null;
+      default:
+        throw new JsonRpcRequestError(-32601, `Method not found: ${method}`);
+    }
+  }
+
+  private buildWorkspaceConfigurationResult(params: unknown): unknown[] {
+    if (!params || typeof params !== "object") return [];
+    const items = (params as { items?: unknown }).items;
+    if (!Array.isArray(items)) return [];
+    return items.map(() => null);
+  }
+
   private handlePublishDiagnostics(params: PublishDiagnosticsParams): void {
     // If the publication includes a version and we have a newer synced
     // version for this open document, ignore the stale publication.

package/src/client/transport.ts

@@ -2,11 +2,12 @@
 
 import type { Readable, Writable } from "node:stream";
 import type {
+  JsonRpcId,
   JsonRpcMessage,
   JsonRpcNotification,
   JsonRpcRequest,
   JsonRpcResponse,
-} from "../types.ts";
+} from "../config/types.ts";
 
 const CONTENT_LENGTH = "Content-Length: ";
 const HEADER_DELIMITER = "\r\n\r\n";
@@ -15,6 +16,7 @@ const DEFAULT_TIMEOUT_MS = 30_000;
 // ── Types ─────────────────────────────────────────────────────────────
 
 export type NotificationHandler = (method: string, params: unknown) => void;
+export type RequestHandler = (method: string, params: unknown) => Promise<unknown> | unknown;
 
 interface PendingRequest {
   resolve: (result: unknown) => void;
@@ -22,13 +24,25 @@ interface PendingRequest {
   timer: ReturnType<typeof setTimeout>;
 }
 
+export class JsonRpcRequestError extends Error {
+  constructor(
+    readonly code: number,
+    message: string,
+    readonly data?: unknown,
+  ) {
+    super(message);
+    this.name = "JsonRpcRequestError";
+  }
+}
+
 // ── JsonRpcClient ─────────────────────────────────────────────────────
 
 export class JsonRpcClient {
   private nextId = 1;
   private buffer = Buffer.alloc(0);
-  private pending = new Map<number, PendingRequest>();
+  private pending = new Map<JsonRpcId, PendingRequest>();
   private notificationHandler: NotificationHandler | null = null;
+  private requestHandler: RequestHandler | null = null;
   private closed = false;
   private readonly timeoutMs: number;
 
@@ -48,6 +62,11 @@ export class JsonRpcClient {
     this.notificationHandler = handler;
   }
 
+  /** Register a handler for server-initiated requests. */
+  onRequest(handler: RequestHandler): void {
+    this.requestHandler = handler;
+  }
+
   /** Send a request and wait for the correlated response, optionally overriding the timeout. */
   sendRequest(
     method: string,
@@ -147,9 +166,11 @@ export class JsonRpcClient {
     // Response (has id, has result or error)
     if ("id" in msg && msg.id != null && ("result" in msg || "error" in msg)) {
       const response = msg as JsonRpcResponse;
-      const pending = this.pending.get(response.id);
+      const id = response.id;
+      if (id === null) return;
+      const pending = this.pending.get(id);
       if (pending) {
-        this.pending.delete(response.id);
+        this.pending.delete(id);
         clearTimeout(pending.timer);
         if (response.error) {
           pending.reject(new Error(`LSP error ${response.error.code}: ${response.error.message}`));
@@ -164,9 +185,44 @@ export class JsonRpcClient {
     if ("method" in msg && !("id" in msg)) {
       const notification = msg as JsonRpcNotification;
       this.notificationHandler?.(notification.method, notification.params);
+      return;
     }
 
-    // Request from server (has id + method) — we don't handle server→client requests yet
+    // Request from server (has id + method)
+    if ("method" in msg && "id" in msg && msg.id != null) {
+      void this.handleInboundRequest(msg as JsonRpcRequest);
+    }
+  }
+
+  private async handleInboundRequest(request: JsonRpcRequest): Promise<void> {
+    if (this.closed) return;
+
+    try {
+      if (!this.requestHandler) {
+        throw new JsonRpcRequestError(-32601, `Method not found: ${request.method}`);
+      }
+
+      const result = await this.requestHandler(request.method, request.params);
+      this.writeMessage({
+        jsonrpc: "2.0",
+        id: request.id,
+        result: result ?? null,
+      } satisfies JsonRpcResponse);
+    } catch (error) {
+      const failure =
+        error instanceof JsonRpcRequestError
+          ? error
+          : new JsonRpcRequestError(-32603, error instanceof Error ? error.message : String(error));
+      this.writeMessage({
+        jsonrpc: "2.0",
+        id: request.id,
+        error: {
+          code: failure.code,
+          message: failure.message,
+          ...(failure.data !== undefined ? { data: failure.data } : {}),
+        },
+      } satisfies JsonRpcResponse);
+    }
   }
 
   private onClose(): void {

package/src/config/tsconfig-scope.ts

@@ -0,0 +1,244 @@
+// tsconfig-aware file scope detection.
+//
+// Determines whether a file is within the compilation scope of its nearest
+// tsconfig.json or jsconfig.json using the TypeScript compiler's own config
+// parsing APIs. Used by the diagnostic filter to suppress LSP errors on files
+// that TypeScript itself would not include in the project.
+
+import * as path from "node:path";
+import ts from "typescript";
+
+interface ParsedProjectConfig {
+  configPath: string;
+  configDir: string;
+  fileNames: Set<string>;
+  explicitFiles: Set<string> | null;
+  includeFilePattern: RegExp | null;
+  excludePattern: RegExp | null;
+  supportedExtensions: Set<string>;
+  usesDefaultInclude: boolean;
+}
+
+const nearestConfigCache = new Map<string, string | null>();
+const parsedConfigCache = new Map<string, ParsedProjectConfig | null>();
+
+const tsInternal = ts as typeof ts & {
+  getFileMatcherPatterns?: (
+    configDir: string,
+    excludes: readonly string[] | undefined,
+    includes: readonly string[] | undefined,
+    useCaseSensitiveFileNames: boolean,
+    currentDirectory: string,
+  ) => {
+    includeFilePattern?: string;
+    excludePattern?: string;
+  };
+  getSupportedExtensions?: (
+    options: ts.CompilerOptions,
+    extraFileExtensions?: unknown,
+  ) => ReadonlyArray<ReadonlyArray<string>>;
+};
+
+/**
+ * Check whether a file is excluded by its nearest tsconfig.json or jsconfig.json.
+ *
+ * @param filePath - Project-relative file path (e.g., "packages/foo/__tests__/x.test.ts")
+ * @param cwd - Absolute project root directory
+ * @returns `true` if the file is excluded from compilation scope
+ */
+export function isFileExcludedByTsconfig(filePath: string, cwd: string): boolean {
+  const absolutePath = path.resolve(cwd, filePath);
+  const configPath = findNearestProjectConfig(path.dirname(absolutePath), cwd);
+  if (!configPath) return false;
+
+  const parsed = parseProjectConfig(configPath);
+  if (!parsed) return false;
+
+  return !isFileInProjectScope(parsed, absolutePath);
+}
+
+/**
+ * Find the nearest tsconfig.json or jsconfig.json walking upward from `startDir`,
+ * stopping at `rootDir`.
+ */
+function findNearestProjectConfig(startDir: string, rootDir: string): string | null {
+  let dir = path.resolve(startDir);
+  const resolvedRoot = path.resolve(rootDir);
+
+  while (true) {
+    const cacheKey = `${normalizePath(dir)}::${normalizePath(resolvedRoot)}`;
+    const cached = nearestConfigCache.get(cacheKey);
+    if (cached !== undefined) return cached;
+
+    const configPath = getLocalProjectConfig(dir);
+    if (configPath) {
+      const resolvedConfigPath = path.resolve(configPath);
+      nearestConfigCache.set(cacheKey, resolvedConfigPath);
+      return resolvedConfigPath;
+    }
+
+    if (path.relative(resolvedRoot, dir).startsWith("..") || dir === resolvedRoot) {
+      nearestConfigCache.set(cacheKey, null);
+      return null;
+    }
+
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      nearestConfigCache.set(cacheKey, null);
+      return null;
+    }
+    dir = parent;
+  }
+}
+
+function getLocalProjectConfig(directory: string): string | null {
+  const tsconfigPath = path.join(directory, "tsconfig.json");
+  if (ts.sys.fileExists(tsconfigPath)) return tsconfigPath;
+
+  const jsconfigPath = path.join(directory, "jsconfig.json");
+  if (ts.sys.fileExists(jsconfigPath)) return jsconfigPath;
+
+  return null;
+}
+
+function parseProjectConfig(configPath: string): ParsedProjectConfig | null {
+  const normalizedConfigPath = normalizePath(configPath);
+  const cached = parsedConfigCache.get(normalizedConfigPath);
+  if (cached !== undefined) return cached;
+
+  const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, createParseConfigHost());
+  if (!parsed) {
+    parsedConfigCache.set(normalizedConfigPath, null);
+    return null;
+  }
+
+  const configDir = path.dirname(path.resolve(configPath));
+  const explicitFiles = extractExplicitFiles(parsed.raw.files, configDir);
+  const usesDefaultInclude = explicitFiles === null && !Array.isArray(parsed.raw.include);
+  const { includeFilePattern, excludePattern } = createFileMatchers(
+    configDir,
+    parsed.raw.include,
+    parsed.raw.exclude,
+    usesDefaultInclude,
+  );
+  const supportedExtensions = new Set(getSupportedExtensions(parsed.options));
+  if (parsed.options.resolveJsonModule) supportedExtensions.add(".json");
+
+  const result = {
+    configPath: path.resolve(configPath),
+    configDir,
+    fileNames: new Set(parsed.fileNames.map(normalizePath)),
+    explicitFiles,
+    includeFilePattern,
+    excludePattern,
+    supportedExtensions,
+    usesDefaultInclude,
+  } satisfies ParsedProjectConfig;
+  parsedConfigCache.set(normalizedConfigPath, result);
+  return result;
+}
+
+function extractExplicitFiles(rawFiles: unknown, configDir: string): Set<string> | null {
+  if (!Array.isArray(rawFiles)) return null;
+  return new Set(
+    rawFiles
+      .filter((entry): entry is string => typeof entry === "string")
+      .map((entry) => normalizePath(path.resolve(configDir, entry))),
+  );
+}
+
+function createFileMatchers(
+  configDir: string,
+  rawInclude: unknown,
+  rawExclude: unknown,
+  useDefaultInclude: boolean,
+): {
+  includeFilePattern: RegExp | null;
+  excludePattern: RegExp | null;
+} {
+  const includeSpecs = Array.isArray(rawInclude)
+    ? rawInclude.filter((entry): entry is string => typeof entry === "string")
+    : undefined;
+  const excludeSpecs = Array.isArray(rawExclude)
+    ? rawExclude.filter((entry): entry is string => typeof entry === "string")
+    : undefined;
+  const matcherPatterns = getFileMatcherPatterns(
+    configDir,
+    excludeSpecs,
+    useDefaultInclude ? ["**/*"] : includeSpecs,
+  );
+
+  return {
+    includeFilePattern: matcherPatterns.includeFilePattern
+      ? new RegExp(matcherPatterns.includeFilePattern)
+      : null,
+    excludePattern: matcherPatterns.excludePattern
+      ? new RegExp(matcherPatterns.excludePattern)
+      : null,
+  };
+}
+
+function isFileInProjectScope(parsed: ParsedProjectConfig, absolutePath: string): boolean {
+  const normalizedPath = normalizePath(absolutePath);
+  if (parsed.fileNames.has(normalizedPath)) return true;
+
+  const extension = path.extname(absolutePath).toLowerCase();
+  if (!parsed.supportedExtensions.has(extension)) return false;
+
+  if (parsed.explicitFiles) return parsed.explicitFiles.has(normalizedPath);
+  if (!isWithinOrEqual(parsed.configDir, absolutePath)) return false;
+  if (parsed.excludePattern?.test(normalizedPath)) return false;
+  if (parsed.usesDefaultInclude) return true;
+  return parsed.includeFilePattern ? parsed.includeFilePattern.test(normalizedPath) : false;
+}
+
+function getSupportedExtensions(options: ts.CompilerOptions): string[] {
+  return tsInternal.getSupportedExtensions
+    ? [...tsInternal.getSupportedExtensions(options, undefined).flat()]
+    : [".ts", ".tsx", ".d.ts", ".cts", ".d.cts", ".mts", ".d.mts"];
+}
+
+function getFileMatcherPatterns(
+  configDir: string,
+  excludeSpecs: readonly string[] | undefined,
+  includeSpecs: readonly string[] | undefined,
+): { includeFilePattern?: string; excludePattern?: string } {
+  return tsInternal.getFileMatcherPatterns
+    ? tsInternal.getFileMatcherPatterns(
+        configDir,
+        excludeSpecs,
+        includeSpecs,
+        ts.sys.useCaseSensitiveFileNames,
+        path.parse(configDir).root,
+      )
+    : {};
+}
+
+function createParseConfigHost(): ts.ParseConfigFileHost {
+  return {
+    ...ts.sys,
+    onUnRecoverableConfigFileDiagnostic: () => {
+      // Treat invalid configs as unsupported rather than surfacing a secondary
+      // filter failure to the agent.
+    },
+  };
+}
+
+function isWithinOrEqual(root: string, target: string): boolean {
+  const relative = path.relative(root, target);
+  return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== "..");
+}
+
+function normalizePath(target: string): string {
+  const resolved = path.resolve(target).replaceAll("\\", "/");
+  return ts.sys.useCaseSensitiveFileNames ? resolved : resolved.toLowerCase();
+}
+
+/**
+ * Clear cached nearest-config lookups and parsed project config state.
+ * Useful for testing and after workspace file changes.
+ */
+export function clearTsconfigCache(): void {
+  nearestConfigCache.clear();
+  parsedConfigCache.clear();
+}

package/src/{types.ts → config/types.ts}

@@ -348,16 +348,18 @@ export interface TextDocumentPositionParams {
 
 // ── JSON-RPC ──────────────────────────────────────────────────────────
 
+export type JsonRpcId = number | string;
+
 export interface JsonRpcRequest {
   jsonrpc: "2.0";
-  id: number;
+  id: JsonRpcId;
   method: string;
   params?: unknown;
 }
 
 export interface JsonRpcResponse {
   jsonrpc: "2.0";
-  id: number;
+  id: JsonRpcId | null;
   result?: unknown;
   error?: { code: number; message: string; data?: unknown };
 }

package/src/coordinates.ts

@@ -0,0 +1,11 @@
+import type { Position } from "./config/types.ts";
+
+/** Convert public 1-based coordinates into a 0-based LSP position. */
+export function toLspPosition(line: number, character: number): Position {
+  return { line: line - 1, character: character - 1 };
+}
+
+/** Convert a 0-based LSP position into 1-based display coordinates. */
+export function toOneBasedPosition(position: Position): { line: number; character: number } {
+  return { line: position.line + 1, character: position.character + 1 };
+}

package/src/diagnostics/diagnostic-augmentation.ts

@@ -1,6 +1,6 @@
-import * as path from "node:path";
+import type { Diagnostic, Hover, MarkedString, MarkupContent } from "../config/types.ts";
 import type { LspManager } from "../manager/manager.ts";
-import type { Diagnostic, Hover, MarkedString, MarkupContent } from "../types.ts";
+import { resolveSessionPath } from "../utils.ts";
 
 const AUGMENT_TIMEOUT_MS = 500;
 
@@ -12,13 +12,13 @@ export async function augmentDiagnostics(
   filePath: string,
   diags: Diagnostic[],
   manager: LspManager,
-  _cwd: string,
+  cwd: string,
 ): Promise<string | null> {
   const firstError = diags.find((d) => d.severity === 1);
   if (!firstError) return null;
 
-  const resolvedPath = path.resolve(filePath);
-  const client = await manager.getClientForFile(filePath);
+  const resolvedPath = resolveSessionPath(cwd, filePath);
+  const client = await manager.getClientForFile(resolvedPath);
   if (!client) return null;
 
   const pos = firstError.range.start;

package/src/diagnostics/diagnostic-context.ts

@@ -0,0 +1,115 @@
+// Diagnostic context formatting for the LSP extension.
+// Extracted from guidance.ts to keep prompt surfaces separate from formatting logic.
+
+import type { Diagnostic } from "../config/types.ts";
+import type { OutstandingDiagnosticSummaryEntry } from "../manager/manager-types.ts";
+import { splitSuppressionDiagnostics } from "./suppression-diagnostics.ts";
+
+export const MAX_DETAILED_DIAGNOSTICS = 5;
+const MAX_DETAIL_LINES_PER_FILE = 3;
+
+interface DetailedDiagnostics {
+  file: string;
+  diagnostics: Diagnostic[];
+}
+
+export function formatDiagnosticsContext(
+  diagnostics: OutstandingDiagnosticSummaryEntry[],
+  maxFiles: number = 3,
+  detailed?: DetailedDiagnostics[],
+  staleWarning?: string | null,
+): string | null {
+  if (diagnostics.length === 0) return null;
+
+  const totalDiags = diagnostics.reduce((sum, d) => sum + d.total, 0);
+  const detailMap = buildDetailMap(totalDiags, detailed);
+
+  const lines: string[] = [];
+  if (staleWarning) lines.push(staleWarning);
+  const visible = diagnostics.slice(0, maxFiles);
+
+  for (const entry of visible) {
+    lines.push(`- ${entry.file}: ${formatCounts(entry)}`);
+    appendDetailLines(lines, detailMap?.get(entry.file));
+  }
+
+  const remaining = diagnostics.length - visible.length;
+  if (remaining > 0) {
+    lines.push(`- +${remaining} more file${remaining === 1 ? "" : "s"}`);
+  }
+
+  appendSuppressionCleanup(
+    lines,
+    visible.map((entry) => entry.file),
+    detailMap,
+  );
+
+  return [
+    '<extension-context source="supi-lsp">',
+    "Outstanding diagnostics — fix these before proceeding:",
+    ...lines,
+    "</extension-context>",
+  ].join("\n");
+}
+
+function buildDetailMap(
+  totalDiags: number,
+  detailed?: DetailedDiagnostics[],
+): Map<string, Diagnostic[]> | null {
+  if (totalDiags > MAX_DETAILED_DIAGNOSTICS || !detailed || detailed.length === 0) return null;
+  return new Map(detailed.map((d) => [d.file, d.diagnostics]));
+}
+
+function appendDetailLines(lines: string[], details?: Diagnostic[]): void {
+  if (!details) return;
+  for (const d of details.slice(0, MAX_DETAIL_LINES_PER_FILE)) {
+    const line = d.range.start.line + 1;
+    const char = d.range.start.character + 1;
+    const source = d.source ? ` ${d.source}` : "";
+    lines.push(`  L${line} C${char}${source}: ${d.message}`);
+  }
+  if (details.length > MAX_DETAIL_LINES_PER_FILE) {
+    const extra = details.length - MAX_DETAIL_LINES_PER_FILE;
+    lines.push(`  +${extra} more`);
+  }
+}
+
+function appendSuppressionCleanup(
+  lines: string[],
+  visibleFiles: string[],
+  detailMap: Map<string, Diagnostic[]> | null,
+): void {
+  if (!detailMap) return;
+
+  const suppressionLines: string[] = [];
+  for (const file of visibleFiles) {
+    const diagnostics = detailMap.get(file);
+    if (!diagnostics) continue;
+
+    const { suppressions } = splitSuppressionDiagnostics(diagnostics, 1);
+    if (suppressions.length === 0) continue;
+
+    suppressionLines.push(`- ${file}`);
+    appendDetailLines(suppressionLines, suppressions);
+  }
+
+  if (suppressionLines.length === 0) return;
+  lines.push("", "Stale suppression comments — clean these up:", ...suppressionLines);
+}
+
+export function diagnosticsContextFingerprint(content: string | null): string | null {
+  return content;
+}
+
+function formatCounts(entry: OutstandingDiagnosticSummaryEntry): string {
+  const counts: string[] = [];
+  if (entry.errors > 0) counts.push(pluralize(entry.errors, "error"));
+  if (entry.warnings > 0) counts.push(pluralize(entry.warnings, "warning"));
+  if (entry.information > 0) counts.push(pluralize(entry.information, "info"));
+  if (entry.hints > 0) counts.push(pluralize(entry.hints, "hint"));
+  return counts.join(", ");
+}
+
+function pluralize(count: number, word: string): string {
+  return `${count} ${word}${count === 1 ? "" : "s"}`;
+}

package/src/diagnostics/diagnostic-display.ts

@@ -1,5 +1,5 @@
+import type { Diagnostic } from "../config/types.ts";
 import type { OutstandingDiagnosticSummaryEntry } from "../manager/manager-types.ts";
-import type { Diagnostic } from "../types.ts";
 
 export function formatDiagnosticsDisplayContent(
   diagnostics: OutstandingDiagnosticSummaryEntry[],

package/src/diagnostics/diagnostic-summary.ts

@@ -1,7 +1,8 @@
+import { type Diagnostic, DiagnosticSeverity } from "../config/types.ts";
 import type { OutstandingDiagnosticSummaryEntry } from "../manager/manager-types.ts";
 import { isGlobMatch } from "../pattern-matcher.ts";
 import { displayRelativeFilePath, shouldIgnoreLspPath } from "../summary.ts";
-import { type Diagnostic, DiagnosticSeverity } from "../types.ts";
+import { uriToFile } from "../utils.ts";
 
 export function collectDiagnosticSummaryCounts(
   fileDiags: Map<string, { errors: number; warnings: number }>,
@@ -52,7 +53,7 @@ export function accumulateOutstandingDiagnostics(
 }
 
 export function relativeFilePathFromUri(uri: string, cwd: string): string {
-  return displayRelativeFilePath(uri.replace("file://", ""), cwd);
+  return displayRelativeFilePath(uriToFile(uri), cwd);
 }
 
 function isDiagnosticWithinThreshold(

package/src/diagnostics/diagnostics.ts

@@ -1,7 +1,7 @@
 // Diagnostic formatting and severity utilities.
 
 import * as path from "node:path";
-import type { Diagnostic } from "../types.ts";
+import type { Diagnostic } from "../config/types.ts";
 
 /** Map severity number to label. */
 export function severityLabel(severity: number | undefined): string {

package/src/diagnostics/stale-diagnostics.ts

@@ -1,4 +1,4 @@
-import type { Diagnostic } from "../types.ts";
+import type { Diagnostic } from "../config/types.ts";
 
 export interface StaleDiagnosticAssessment {
   suspected: boolean;

package/src/diagnostics/suppression-diagnostics.ts

@@ -1,4 +1,4 @@
-import type { Diagnostic } from "../types.ts";
+import type { Diagnostic } from "../config/types.ts";
 
 const SUPPRESSION_WARNING_SEVERITY = 2;
 

package/src/{workspace-sentinels.ts → diagnostics/workspace-sentinels.ts}

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { FileChangeType, type FileEvent } from "./types.ts";
-import { fileToUri } from "./utils.ts";
+import { FileChangeType, type FileEvent } from "../config/types.ts";
+import { fileToUri } from "../utils.ts";
 
 const IGNORED_DIRECTORIES = new Set(["node_modules", ".pnpm", ".git", "dist", "coverage"]);
 const ROOT_LOCKFILES = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb"];