@mrclrchtr/supi-lsp 0.1.0 → 1.1.2

package/bash-guard.ts

@@ -1,58 +0,0 @@
-const SEMANTIC_PROMPT_PATTERNS = [
-  /\bdefinition\b/i,
-  /\bfind(?: all)? references?\b/i,
-  /\breferences?\b/i,
-  /\busages?\b/i,
-  /\bsymbols?\b/i,
-  /\bhover\b/i,
-  /\brename\b/i,
-  /\bcode actions?\b/i,
-  /\bdiagnostics?\b/i,
-  /\btype errors?\b/i,
-  /\bwarning\b/i,
-];
-
-const TEXT_SEARCH_COMMAND_PATTERNS = [
-  /\brg\b/,
-  /\bripgrep\b/,
-  /\bgrep\b/,
-  /\bgit\s+grep\b/,
-  /\back\b/,
-  /\bag\b/,
-];
-
-/**
- * Returns a redirect message when the agent is about to run a text-search
- * command (rg/grep/etc.) for a clearly semantic question (definitions,
- * references, symbols, diagnostics…) over files that already have active LSP
- * coverage. In that combination the lsp tool is strictly more accurate, so we
- * block the bash call and steer the agent to lsp. Returns null otherwise — we
- * don't interfere with plain-text searches or with searches that fall outside
- * the active LSP coverage.
- */
-export function shouldBlockSemanticBashSearch(
-  command: string,
-  prompt: string,
-  relevantPaths: string[],
-  hasRelevantCoverage: boolean,
-): string | null {
-  if (!hasRelevantCoverage) return null;
-  if (!isSemanticPrompt(prompt) || !isTextSearchCommand(command)) return null;
-
-  const visiblePaths = relevantPaths.slice(0, 2).join(", ");
-  const targetText = visiblePaths ? ` in ${visiblePaths}` : " in files with active LSP coverage";
-
-  return [
-    "Use the lsp tool instead of bash text search for semantic queries.",
-    `Active LSP coverage is available${targetText}.`,
-    "Prefer lsp for definitions, references, symbols, hover, rename planning, code actions, and diagnostics.",
-  ].join(" ");
-}
-
-export function isSemanticPrompt(prompt: string): boolean {
-  return SEMANTIC_PROMPT_PATTERNS.some((pattern) => pattern.test(prompt));
-}
-
-export function isTextSearchCommand(command: string): boolean {
-  return TEXT_SEARCH_COMMAND_PATTERNS.some((pattern) => pattern.test(command));
-}

package/config.ts

@@ -1,99 +0,0 @@
-// LSP server configuration — load defaults, merge with project overrides.
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { LspConfig, ServerConfig } from "./types.ts";
-
-// Load defaults at module level — resolve relative to this file.
-// pi loads extensions via jiti, which always provides __dirname.
-const DEFAULTS: LspConfig = JSON.parse(
-  fs.readFileSync(path.join(__dirname, "defaults.json"), "utf-8"),
-) as LspConfig;
-
-// ── Public API ────────────────────────────────────────────────────────
-
-/**
- * Load LSP config: built-in defaults merged with optional `.pi-lsp.json`
- * from the project root. Project config takes precedence.
- */
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: straightforward merge logic
-export function loadConfig(cwd: string): LspConfig {
-  const defaults = DEFAULTS;
-  const projectOverrides = loadProjectConfig(cwd);
-
-  // Start from defaults, merge project overrides if present
-  const merged: Record<string, ServerConfig> = { ...defaults.servers };
-
-  if (projectOverrides) {
-    for (const [name, override] of Object.entries(projectOverrides.servers)) {
-      if (override.enabled === false) {
-        delete merged[name];
-        continue;
-      }
-      if (merged[name]) {
-        merged[name] = { ...merged[name], ...override };
-      } else {
-        // New server from project config — must have all required fields
-        if (override.command && override.fileTypes && override.rootMarkers) {
-          merged[name] = override as ServerConfig;
-        }
-      }
-    }
-  }
-
-  // Apply PI_LSP_SERVERS filter (always, even without project config)
-  const allowList = getServerAllowList();
-  if (allowList) {
-    for (const name of Object.keys(merged)) {
-      if (!allowList.has(name)) {
-        delete merged[name];
-      }
-    }
-  }
-
-  return { servers: merged };
-}
-
-/**
- * Find which server config handles a given file extension.
- * Returns [serverName, config] or null.
- */
-export function getServerForFile(
-  config: LspConfig,
-  filePath: string,
-): [string, ServerConfig] | null {
-  const ext = path.extname(filePath).slice(1).toLowerCase();
-  if (!ext) return null;
-
-  for (const [name, server] of Object.entries(config.servers)) {
-    if (server.fileTypes.includes(ext)) {
-      return [name, server];
-    }
-  }
-  return null;
-}
-
-// ── Private ───────────────────────────────────────────────────────────
-
-function loadProjectConfig(cwd: string): LspConfig | null {
-  const jsonPath = path.join(cwd, ".pi-lsp.json");
-
-  if (fs.existsSync(jsonPath)) {
-    try {
-      const content = fs.readFileSync(jsonPath, "utf-8");
-      return JSON.parse(content) as LspConfig;
-    } catch {}
-  }
-
-  return null;
-}
-
-function getServerAllowList(): Set<string> | null {
-  const env = process.env.PI_LSP_SERVERS;
-  if (!env) return null;
-  const names = env
-    .split(",")
-    .map((s) => s.trim())
-    .filter(Boolean);
-  return names.length > 0 ? new Set(names) : null;
-}

package/defaults.json

@@ -1,40 +0,0 @@
-{
-  "servers": {
-    "typescript-language-server": {
-      "command": "typescript-language-server",
-      "args": ["--stdio"],
-      "fileTypes": ["ts", "tsx", "js", "jsx", "mts", "cts", "mjs", "cjs"],
-      "rootMarkers": ["tsconfig.json", "jsconfig.json", "package.json"]
-    },
-    "pyright": {
-      "command": "pyright-langserver",
-      "args": ["--stdio"],
-      "fileTypes": ["py", "pyi"],
-      "rootMarkers": [
-        "pyproject.toml",
-        "setup.py",
-        "setup.cfg",
-        "requirements.txt",
-        "pyrightconfig.json"
-      ]
-    },
-    "rust-analyzer": {
-      "command": "rust-analyzer",
-      "args": [],
-      "fileTypes": ["rs"],
-      "rootMarkers": ["Cargo.toml"]
-    },
-    "gopls": {
-      "command": "gopls",
-      "args": ["serve"],
-      "fileTypes": ["go", "mod"],
-      "rootMarkers": ["go.mod", "go.sum"]
-    },
-    "clangd": {
-      "command": "clangd",
-      "args": ["--background-index"],
-      "fileTypes": ["c", "h", "cpp", "hpp", "cc", "cxx", "hxx", "c++", "h++"],
-      "rootMarkers": ["compile_commands.json", "CMakeLists.txt", ".clangd", "Makefile"]
-    }
-  }
-}

package/format.ts

@@ -1,190 +0,0 @@
-// LSP result formatting — converts LSP response types into readable text.
-
-import * as path from "node:path";
-import type {
-  CodeAction,
-  DocumentSymbol,
-  Hover,
-  Location,
-  LocationLink,
-  MarkedString,
-  MarkupContent,
-  SymbolInformation,
-  WorkspaceEdit,
-} from "./types.ts";
-import { uriToFile } from "./utils.ts";
-
-// ── Hover ─────────────────────────────────────────────────────────────
-
-export function formatHover(hover: Hover): string {
-  const contents = hover.contents;
-
-  if (typeof contents === "string") return contents;
-  if ("value" in contents) {
-    const mc = contents as MarkupContent | { language: string; value: string };
-    if ("kind" in mc) return mc.value;
-    return `\`\`\`${mc.language}\n${mc.value}\n\`\`\``;
-  }
-  if (Array.isArray(contents)) {
-    return (contents as MarkedString[])
-      .map((c) => (typeof c === "string" ? c : `\`\`\`${c.language}\n${c.value}\n\`\`\``))
-      .join("\n\n");
-  }
-
-  return String(contents);
-}
-
-// ── Locations ─────────────────────────────────────────────────────────
-
-export function formatLocations(label: string, locations: Location[]): string {
-  if (locations.length === 1) {
-    const loc = locations[0];
-    const file = relPath(uriToFile(loc.uri));
-    const line = loc.range.start.line + 1;
-    const col = loc.range.start.character + 1;
-    return `${label}: ${file}:${line}:${col}`;
-  }
-
-  const lines = [`${label} (${locations.length} locations):\n`];
-  for (const loc of locations) {
-    const file = relPath(uriToFile(loc.uri));
-    const line = loc.range.start.line + 1;
-    const col = loc.range.start.character + 1;
-    lines.push(`- ${file}:${line}:${col}`);
-  }
-  return lines.join("\n");
-}
-
-export function normalizeLocations(result: Location | Location[] | LocationLink[]): Location[] {
-  if (Array.isArray(result)) {
-    return result.map((item) => {
-      if ("targetUri" in item) {
-        const link = item as LocationLink;
-        return { uri: link.targetUri, range: link.targetSelectionRange };
-      }
-      return item as Location;
-    });
-  }
-  return [result as Location];
-}
-
-// ── Symbols ───────────────────────────────────────────────────────────
-
-export function formatDocumentSymbols(symbols: DocumentSymbol[], indent: number): string {
-  const lines: string[] = [];
-  const prefix = "  ".repeat(indent);
-
-  for (const sym of symbols) {
-    const kind = symbolKindName(sym.kind);
-    const line = sym.selectionRange.start.line + 1;
-    const detail = sym.detail ? ` — ${sym.detail}` : "";
-    lines.push(`${prefix}- ${kind} **${sym.name}**${detail} (line ${line})`);
-
-    if (sym.children && sym.children.length > 0) {
-      lines.push(formatDocumentSymbols(sym.children, indent + 1));
-    }
-  }
-
-  return lines.join("\n");
-}
-
-export function formatSymbolInformation(symbols: SymbolInformation[]): string {
-  const lines: string[] = [];
-  for (const sym of symbols) {
-    const kind = symbolKindName(sym.kind);
-    const file = relPath(uriToFile(sym.location.uri));
-    const line = sym.location.range.start.line + 1;
-    const container = sym.containerName ? ` (in ${sym.containerName})` : "";
-    lines.push(`- ${kind} **${sym.name}**${container} — ${file}:${line}`);
-  }
-  return lines.join("\n");
-}
-
-// ── Workspace Edits ───────────────────────────────────────────────────
-
-export function formatWorkspaceEdit(edit: WorkspaceEdit): string {
-  const lines: string[] = ["Rename workspace edit:\n"];
-
-  if (edit.changes) {
-    for (const [uri, edits] of Object.entries(edit.changes)) {
-      const file = relPath(uriToFile(uri));
-      lines.push(`**${file}** (${edits.length} change(s))`);
-      for (const e of edits) {
-        const line = e.range.start.line + 1;
-        lines.push(`  Line ${line}: → "${e.newText}"`);
-      }
-    }
-  }
-
-  if (edit.documentChanges) {
-    for (const dc of edit.documentChanges) {
-      const file = relPath(uriToFile(dc.textDocument.uri));
-      lines.push(`**${file}** (${dc.edits.length} change(s))`);
-      for (const e of dc.edits) {
-        const line = e.range.start.line + 1;
-        lines.push(`  Line ${line}: → "${e.newText}"`);
-      }
-    }
-  }
-
-  return lines.join("\n");
-}
-
-// ── Code Actions ──────────────────────────────────────────────────────
-
-export function formatCodeActions(actions: CodeAction[]): string {
-  const lines = [`Available code actions (${actions.length}):\n`];
-  for (const action of actions) {
-    const kind = action.kind ? ` [${action.kind}]` : "";
-    const preferred = action.isPreferred ? " ⭐" : "";
-    lines.push(`- **${action.title}**${kind}${preferred}`);
-    if (action.edit) {
-      const fileCount = action.edit.changes
-        ? Object.keys(action.edit.changes).length
-        : (action.edit.documentChanges?.length ?? 0);
-      lines.push(`  Edits ${fileCount} file(s)`);
-    }
-  }
-  return lines.join("\n");
-}
-
-// ── Symbol Kind Names ─────────────────────────────────────────────────
-
-const SYMBOL_KIND_NAMES: Record<number, string> = {
-  1: "File",
-  2: "Module",
-  3: "Namespace",
-  4: "Package",
-  5: "Class",
-  6: "Method",
-  7: "Property",
-  8: "Field",
-  9: "Constructor",
-  10: "Enum",
-  11: "Interface",
-  12: "Function",
-  13: "Variable",
-  14: "Constant",
-  15: "String",
-  16: "Number",
-  17: "Boolean",
-  18: "Array",
-  19: "Object",
-  20: "Key",
-  21: "Null",
-  22: "EnumMember",
-  23: "Struct",
-  24: "Event",
-  25: "Operator",
-  26: "TypeParameter",
-};
-
-function symbolKindName(kind: number): string {
-  return SYMBOL_KIND_NAMES[kind] ?? `Kind(${kind})`;
-}
-
-// ── Helpers ───────────────────────────────────────────────────────────
-
-function relPath(filePath: string): string {
-  return path.relative(process.cwd(), filePath);
-}

package/guidance.ts

@@ -1,140 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { LspManager } from "./manager.ts";
-
-export const lspPromptSnippet =
-  "Use semantic code intelligence for hover, definitions, references, symbols, rename planning, code actions, and diagnostics in supported languages.";
-
-export const lspPromptGuidelines = [
-  "Prefer the lsp tool over bash text search for supported source files when the task is semantic code navigation or diagnostics.",
-  "Use lsp for hover, definitions, references, document symbols, rename planning, code actions, and diagnostics before falling back to grep-style shell search.",
-  "Fall back to bash/read when LSP is unavailable, the file type is unsupported, or the task is plain-text search across docs, config files, or string literals.",
-];
-
-type DiagnosticsManager = Pick<LspManager, "getRelevantOutstandingDiagnosticsSummaryText">;
-
-type GuidanceMessageLike = {
-  customType?: string;
-  details?: unknown;
-};
-
-export interface RuntimeGuidanceInput {
-  pendingActivation: boolean;
-  diagnosticsSummary: string | null;
-  trackedFiles: string[];
-}
-
-export function computeTrackedDiagnosticsSummary(
-  manager: DiagnosticsManager,
-  inlineSeverity: number,
-  trackedPaths: string[],
-): string | null {
-  if (trackedPaths.length === 0) return null;
-  return manager.getRelevantOutstandingDiagnosticsSummaryText(trackedPaths, inlineSeverity);
-}
-
-export function buildRuntimeLspGuidance(input: RuntimeGuidanceInput): string | null {
-  const lines: string[] = [];
-  const fileHint = summarizeTrackedFiles(input.trackedFiles);
-
-  if (input.pendingActivation) {
-    lines.push(
-      fileHint
-        ? `LSP ready for semantic navigation on tracked source files (${fileHint}).`
-        : "LSP ready for semantic navigation on the tracked source files.",
-    );
-  } else if (fileHint) {
-    // After activation, surface the current tracked-file context so the agent
-    // sees newly touched supported source files reflected in runtime guidance.
-    // Dedup is the caller's job (fingerprint match → skip).
-    lines.push(`LSP tracking source files: ${fileHint}.`);
-  }
-
-  if (input.diagnosticsSummary) {
-    lines.push(input.diagnosticsSummary);
-  }
-
-  if (lines.length === 0) return null;
-
-  return ["LSP guidance:", ...lines.map((line) => `- ${line}`)].join("\n");
-}
-
-/**
- * Fingerprint captures the parts of runtime guidance that persist across turns
- * — tracked source-file set and tracked diagnostics summary. `pendingActivation`
- * is a one-shot signal cleared after injection, so it's excluded; otherwise an
- * unchanged-state turn would never match the previously stored fingerprint.
- * Tracked files are included so newly opened supported files re-trigger
- * guidance even when diagnostics are unchanged.
- */
-export function runtimeGuidanceFingerprint(input: RuntimeGuidanceInput): string {
-  // Canonicalize by sorting: registerQualifyingSourceInteraction moves the most
-  // recent file to the front of trackedSourcePaths, so an order-sensitive join
-  // would treat re-touching an already-tracked file as a state change and
-  // re-inject guidance during ordinary back-and-forth edits.
-  const canonical = [...input.trackedFiles].sort().join("|");
-  return `${canonical}\u0000${input.diagnosticsSummary ?? ""}`;
-}
-
-export function extractPromptPathHints(prompt: string, cwd: string = process.cwd()): string[] {
-  const tokens = prompt.match(/[A-Za-z0-9_./-]+/g) ?? [];
-  const matches = new Set<string>();
-
-  for (const token of tokens) {
-    const candidate = normalizePromptPathHint(token);
-    if (!candidate) continue;
-
-    const resolved = path.resolve(cwd, candidate);
-    if (!fs.existsSync(resolved)) continue;
-
-    const relative = path.relative(cwd, resolved);
-    if (relative === "") {
-      matches.add(path.basename(resolved));
-      continue;
-    }
-
-    if (!relative.startsWith(`..${path.sep}`) && relative !== "..") {
-      matches.add(relative.replaceAll(path.sep, "/"));
-    }
-  }
-
-  return Array.from(matches);
-}
-
-export function mergeRelevantPaths(
-  promptPaths: string[],
-  recentPaths: string[],
-  maxEntries: number = 8,
-): string[] {
-  return Array.from(new Set([...promptPaths, ...recentPaths])).slice(0, maxEntries);
-}
-
-export function filterLspGuidanceMessages<T extends GuidanceMessageLike>(
-  messages: T[],
-  activeGuidanceToken: string | null,
-): T[] {
-  return messages.filter((message) => {
-    if (message.customType !== "lsp-guidance") return true;
-    if (!activeGuidanceToken) return false;
-    return getGuidanceToken(message.details) === activeGuidanceToken;
-  });
-}
-
-function summarizeTrackedFiles(files: string[], maxFiles: number = 2): string {
-  if (files.length === 0) return "";
-  const shown = files.slice(0, maxFiles).join(", ");
-  const remaining = files.length - maxFiles;
-  return remaining > 0 ? `${shown}, +${remaining} more` : shown;
-}
-
-function getGuidanceToken(details: unknown): string | null {
-  if (!details || typeof details !== "object") return null;
-  const token = (details as { guidanceToken?: unknown }).guidanceToken;
-  return typeof token === "string" ? token : null;
-}
-
-function normalizePromptPathHint(token: string): string | null {
-  const cleaned = token.replace(/^[`'"([]+|[`'"),.:;\]]+$/g, "");
-  if (cleaned.length < 2) return null;
-  return cleaned;
-}