@mrclrchtr/supi-code-intelligence 1.3.0 → 1.4.0

package/node_modules/@mrclrchtr/supi-lsp/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/node_modules/@mrclrchtr/supi-lsp/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/node_modules/@mrclrchtr/supi-lsp/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/node_modules/@mrclrchtr/supi-lsp/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/node_modules/@mrclrchtr/supi-lsp/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/node_modules/@mrclrchtr/supi-lsp/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/node_modules/@mrclrchtr/supi-lsp/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/node_modules/@mrclrchtr/supi-lsp/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/node_modules/@mrclrchtr/supi-lsp/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/node_modules/@mrclrchtr/supi-lsp/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/node_modules/@mrclrchtr/supi-lsp/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"];

package/node_modules/@mrclrchtr/supi-lsp/src/format.ts

@@ -1,8 +1,6 @@
 // LSP result formatting — converts LSP response types into readable text.
 
 import * as path from "node:path";
-import type { GrepMatch } from "./search-fallback.ts";
-import { isProjectSource } from "./summary.ts";
 import type {
   CodeAction,
   DocumentSymbol,
@@ -13,7 +11,8 @@ import type {
   MarkupContent,
   SymbolInformation,
   WorkspaceEdit,
-} from "./types.ts";
+} from "./config/types.ts";
+import { isProjectSource } from "./summary.ts";
 import { uriToFile } from "./utils.ts";
 
 // ── Hover ─────────────────────────────────────────────────────────────
@@ -297,26 +296,6 @@ export function formatWorkspaceSymbols(symbols: SymbolInformation[], cwd: string
   return lines.join("\n");
 }
 
-// ── Search Results ────────────────────────────────────────────────────
-
-export function formatSearchResults(
-  lspSymbols: SymbolInformation[] | null,
-  grepMatches: GrepMatch[] | null,
-  cwd: string,
-): string {
-  if (lspSymbols && lspSymbols.length > 0) {
-    return formatWorkspaceSymbols(lspSymbols, cwd);
-  }
-  if (grepMatches && grepMatches.length > 0) {
-    const lines = [`Text search results (${grepMatches.length}):\n`];
-    for (const match of grepMatches) {
-      lines.push(`- ${match.file}:${match.line}: ${match.text}`);
-    }
-    return lines.join("\n");
-  }
-  return "No symbols or text matches found.";
-}
-
 // ── Symbol Kind Names ─────────────────────────────────────────────────
 
 const SYMBOL_KIND_NAMES: Record<number, string> = {

package/node_modules/@mrclrchtr/supi-lsp/src/index.ts

@@ -1,10 +1,9 @@
 // Public library entrypoint for @mrclrchtr/supi-lsp/api.
-// Import from the package root to reuse session-scoped LSP services
-// without reaching into private implementation files.
+// Consumers should import the published API surface from
+// `@mrclrchtr/supi-lsp/api`, not the package root.
 
-export type { SessionLspServiceState } from "./service-registry.ts";
-export { getSessionLspService, SessionLspService } from "./service-registry.ts";
 export type {
+  CodeAction,
   Diagnostic,
   DocumentSymbol,
   Hover,
@@ -12,6 +11,20 @@ export type {
   LocationLink,
   Position,
   ProjectServerInfo,
+  Range,
   SymbolInformation,
+  WorkspaceEdit,
   WorkspaceSymbol,
-} from "./types.ts";
+} from "./config/types.ts";
+export { toLspPosition, toOneBasedPosition } from "./coordinates.ts";
+export type {
+  OutstandingDiagnosticSummaryEntry,
+  RecoverDiagnosticsResult,
+  SessionLspServiceState,
+  WorkspaceDiagnosticSummaryEntry,
+} from "./session/service-registry.ts";
+export {
+  getSessionLspService,
+  SessionLspService,
+  waitForSessionLspService,
+} from "./session/service-registry.ts";