@mrclrchtr/supi-code-intelligence 0.1.0

package/node_modules/@mrclrchtr/supi-lsp/src/client/transport.ts

@@ -0,0 +1,192 @@
+// JSON-RPC 2.0 transport over stdio with Content-Length header framing.
+
+import type { Readable, Writable } from "node:stream";
+import type {
+  JsonRpcMessage,
+  JsonRpcNotification,
+  JsonRpcRequest,
+  JsonRpcResponse,
+} from "../types.ts";
+
+const CONTENT_LENGTH = "Content-Length: ";
+const HEADER_DELIMITER = "\r\n\r\n";
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+// ── Types ─────────────────────────────────────────────────────────────
+
+export type NotificationHandler = (method: string, params: unknown) => void;
+
+interface PendingRequest {
+  resolve: (result: unknown) => void;
+  reject: (error: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+// ── JsonRpcClient ─────────────────────────────────────────────────────
+
+export class JsonRpcClient {
+  private nextId = 1;
+  private buffer = Buffer.alloc(0);
+  private pending = new Map<number, PendingRequest>();
+  private notificationHandler: NotificationHandler | null = null;
+  private closed = false;
+  private readonly timeoutMs: number;
+
+  constructor(
+    private readonly input: Readable,
+    private readonly output: Writable,
+    options?: { timeoutMs?: number },
+  ) {
+    this.timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.input.on("data", (chunk: Buffer) => this.onData(chunk));
+    this.input.on("end", () => this.onClose());
+    this.input.on("error", () => this.onClose());
+  }
+
+  /** Register a handler for server notifications (no id). */
+  onNotification(handler: NotificationHandler): void {
+    this.notificationHandler = handler;
+  }
+
+  /** Send a request and wait for the correlated response, optionally overriding the timeout. */
+  sendRequest(
+    method: string,
+    params?: unknown,
+    options?: { timeoutMs?: number },
+  ): Promise<unknown> {
+    if (this.closed) {
+      return Promise.reject(new Error("JSON-RPC client is closed"));
+    }
+
+    const id = this.nextId++;
+    const timeoutMs = options?.timeoutMs ?? this.timeoutMs;
+    const promise = new Promise<unknown>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Request ${method} (id=${id}) timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      this.pending.set(id, { resolve, reject, timer });
+    });
+
+    const msg: JsonRpcRequest = { jsonrpc: "2.0", id, method, params };
+    this.writeMessage(msg);
+
+    // Prevent unhandled rejection when dispose() rejects orphaned promises
+    promise.catch(() => {});
+    return promise;
+  }
+
+  /** Send a notification (no response expected). */
+  sendNotification(method: string, params?: unknown): void {
+    if (this.closed) return;
+    const msg: JsonRpcNotification = { jsonrpc: "2.0", method, params };
+    this.writeMessage(msg);
+  }
+
+  /** Clean up all pending requests. */
+  dispose(): void {
+    this.closed = true;
+    for (const [id, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(new Error("JSON-RPC client disposed"));
+      this.pending.delete(id);
+    }
+  }
+
+  // ── Private ───────────────────────────────────────────────────────
+
+  private writeMessage(msg: JsonRpcMessage): void {
+    const body = JSON.stringify(msg);
+    const contentLength = Buffer.byteLength(body, "utf-8");
+    const header = `${CONTENT_LENGTH}${contentLength}${HEADER_DELIMITER}`;
+    this.output.write(header + body);
+  }
+
+  private onData(chunk: Buffer): void {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    this.processBuffer();
+  }
+
+  private processBuffer(): void {
+    while (true) {
+      // Look for header delimiter
+      const headerEnd = this.buffer.indexOf(HEADER_DELIMITER);
+      if (headerEnd === -1) return;
+
+      // Parse Content-Length from headers
+      const headerText = this.buffer.subarray(0, headerEnd).toString("utf-8");
+      const contentLength = parseContentLength(headerText);
+      if (contentLength === null) {
+        // Malformed header — skip past delimiter and try again
+        this.buffer = this.buffer.subarray(headerEnd + HEADER_DELIMITER.length);
+        continue;
+      }
+
+      // Check if we have the full body
+      const bodyStart = headerEnd + HEADER_DELIMITER.length;
+      const messageEnd = bodyStart + contentLength;
+      if (this.buffer.length < messageEnd) {
+        return; // Need more data — partial message
+      }
+
+      // Extract and parse the body
+      const body = this.buffer.subarray(bodyStart, messageEnd).toString("utf-8");
+      this.buffer = this.buffer.subarray(messageEnd);
+
+      try {
+        const msg = JSON.parse(body) as JsonRpcMessage;
+        this.handleMessage(msg);
+      } catch {
+        // Malformed JSON — skip
+      }
+    }
+  }
+
+  private handleMessage(msg: JsonRpcMessage): void {
+    // 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);
+      if (pending) {
+        this.pending.delete(response.id);
+        clearTimeout(pending.timer);
+        if (response.error) {
+          pending.reject(new Error(`LSP error ${response.error.code}: ${response.error.message}`));
+        } else {
+          pending.resolve(response.result);
+        }
+      }
+      return;
+    }
+
+    // Notification (no id)
+    if ("method" in msg && !("id" in msg)) {
+      const notification = msg as JsonRpcNotification;
+      this.notificationHandler?.(notification.method, notification.params);
+    }
+
+    // Request from server (has id + method) — we don't handle server→client requests yet
+  }
+
+  private onClose(): void {
+    this.closed = true;
+    for (const [id, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(new Error("JSON-RPC connection closed"));
+      this.pending.delete(id);
+    }
+  }
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────
+
+function parseContentLength(header: string): number | null {
+  for (const line of header.split("\r\n")) {
+    if (line.startsWith(CONTENT_LENGTH)) {
+      const value = parseInt(line.slice(CONTENT_LENGTH.length), 10);
+      if (Number.isFinite(value) && value >= 0) return value;
+    }
+  }
+  return null;
+}

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

@@ -0,0 +1,143 @@
+// LSP server configuration — load defaults, merge with supi config per language key.
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadSupiConfigForScope } from "@mrclrchtr/supi-core";
+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 ────────────────────────────────────────────────────────
+
+export interface LoadConfigOptions {
+  homeDir?: string;
+}
+
+/** Map from language alias → canonical config key. */
+export const LANGUAGE_ALIASES: Record<string, string> = {
+  cpp: "c",
+};
+
+/** Resolve a language name through aliases. */
+export function resolveLanguageAlias(name: string): string {
+  return LANGUAGE_ALIASES[name] ?? name;
+}
+
+function resolveAliasesInOverrides(servers: Record<string, Partial<ServerConfig>>): void {
+  for (const [alias, target] of Object.entries(LANGUAGE_ALIASES)) {
+    if (servers[alias]) {
+      servers[target] = { ...(servers[target] ?? {}), ...servers[alias] };
+      delete servers[alias];
+    }
+  }
+}
+
+/**
+ * Load LSP config: built-in defaults merged with per-language-key overrides
+ * from supi config (`~/.pi/agent/supi/config.json` and `.pi/supi/config.json`).
+ * Each language key merges individually; omitted fields fall back to defaults.
+ */
+export function loadConfig(cwd: string, options?: LoadConfigOptions): LspConfig {
+  const defaults = DEFAULTS;
+
+  const globalLsp = loadSupiConfigForScope(
+    "lsp",
+    cwd,
+    { enabled: true, severity: 1, active: [], servers: {} as Record<string, ServerConfig> },
+    { scope: "global", homeDir: options?.homeDir },
+  );
+  const projectLsp = loadSupiConfigForScope(
+    "lsp",
+    cwd,
+    { enabled: true, severity: 1, active: [], servers: {} as Record<string, ServerConfig> },
+    { scope: "project" },
+  );
+
+  const merged = mergeServerConfigs(defaults.servers, globalLsp.servers, projectLsp.servers);
+
+  return { servers: merged };
+}
+
+/**
+ * Find which server config handles a given file extension.
+ * Returns [languageName, 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 mergeServerConfigs(
+  defaults: Record<string, ServerConfig>,
+  globalOverrides: unknown,
+  projectOverrides: unknown,
+): Record<string, ServerConfig> {
+  const merged: Record<string, ServerConfig> = { ...defaults };
+
+  const globalServers = isServerRecord(globalOverrides) ? globalOverrides : {};
+  const projectServers = isServerRecord(projectOverrides) ? projectOverrides : {};
+
+  resolveAliasesInOverrides(globalServers);
+  resolveAliasesInOverrides(projectServers);
+
+  // Apply global per-key overrides against defaults
+  for (const [lang, override] of Object.entries(globalServers)) {
+    const result = mergeSingleServer(defaults[lang], override);
+    if (result) merged[lang] = result;
+  }
+
+  // Apply project per-key overrides against the result so far
+  for (const [lang, override] of Object.entries(projectServers)) {
+    const result = mergeSingleServer(merged[lang] ?? defaults[lang], override);
+    if (result) merged[lang] = result;
+  }
+
+  // Remove servers whose final merged config has enabled === false
+  for (const [lang, config] of Object.entries(merged)) {
+    if (config.enabled === false) {
+      delete merged[lang];
+    }
+  }
+
+  return merged;
+}
+
+function mergeSingleServer(
+  base: ServerConfig | undefined,
+  override: Partial<ServerConfig>,
+): ServerConfig | null {
+  if (!base) {
+    // New custom language — must have all required fields
+    if (
+      override.command &&
+      Array.isArray(override.fileTypes) &&
+      override.fileTypes.length > 0 &&
+      Array.isArray(override.rootMarkers) &&
+      override.rootMarkers.length > 0
+    ) {
+      return override as ServerConfig;
+    }
+    return null;
+  }
+  return { ...base, ...override };
+}
+
+function isServerRecord(value: unknown): value is Record<string, Partial<ServerConfig>> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/node_modules/@mrclrchtr/supi-lsp/src/defaults.json

@@ -0,0 +1,82 @@
+{
+  "servers": {
+    "typescript": {
+      "command": "typescript-language-server",
+      "args": ["--stdio"],
+      "fileTypes": ["ts", "tsx", "js", "jsx", "mts", "cts", "mjs", "cjs"],
+      "rootMarkers": ["tsconfig.json", "jsconfig.json", "package.json"]
+    },
+    "python": {
+      "command": "pyright-langserver",
+      "args": ["--stdio"],
+      "fileTypes": ["py", "pyi"],
+      "rootMarkers": [
+        "pyproject.toml",
+        "setup.py",
+        "setup.cfg",
+        "requirements.txt",
+        "pyrightconfig.json"
+      ]
+    },
+    "rust": {
+      "command": "rust-analyzer",
+      "args": [],
+      "fileTypes": ["rs"],
+      "rootMarkers": ["Cargo.toml"]
+    },
+    "go": {
+      "command": "gopls",
+      "args": ["serve"],
+      "fileTypes": ["go", "mod"],
+      "rootMarkers": ["go.mod", "go.sum"]
+    },
+    "c": {
+      "command": "clangd",
+      "args": ["--background-index"],
+      "fileTypes": ["c", "h", "cpp", "hpp", "cc", "cxx", "hxx", "c++", "h++"],
+      "rootMarkers": ["compile_commands.json", "CMakeLists.txt", ".clangd", "Makefile"]
+    },
+    "ruby": {
+      "command": "ruby-lsp",
+      "args": [],
+      "fileTypes": ["rb", "erb", "gemspec"],
+      "rootMarkers": ["Gemfile", ".ruby-version"]
+    },
+    "java": {
+      "command": "jdtls",
+      "args": [],
+      "fileTypes": ["java"],
+      "rootMarkers": ["pom.xml", "build.gradle"]
+    },
+    "kotlin": {
+      "command": "kotlin-lsp",
+      "args": [],
+      "fileTypes": ["kt", "kts"],
+      "rootMarkers": ["build.gradle.kts", "pom.xml"]
+    },
+    "bash": {
+      "command": "bash-language-server",
+      "args": ["start"],
+      "fileTypes": ["sh", "bash", "zsh", "ksh"],
+      "rootMarkers": []
+    },
+    "html": {
+      "command": "vscode-html-language-server",
+      "args": ["--stdio"],
+      "fileTypes": ["html", "htm", "xhtml"],
+      "rootMarkers": ["package.json"]
+    },
+    "sql": {
+      "command": "sql-language-server",
+      "args": ["up", "--method", "stdio"],
+      "fileTypes": ["sql"],
+      "rootMarkers": []
+    },
+    "r": {
+      "command": "R",
+      "args": ["--slave", "-e", "languageserver::run()"],
+      "fileTypes": ["r"],
+      "rootMarkers": ["DESCRIPTION", "renv.lock", ".Rprofile"]
+    }
+  }
+}

package/node_modules/@mrclrchtr/supi-lsp/src/diagnostics/diagnostic-augmentation.ts

@@ -0,0 +1,82 @@
+import * as path from "node:path";
+import type { LspManager } from "../manager/manager.ts";
+import type { Diagnostic, Hover, MarkedString, MarkupContent } from "../types.ts";
+
+const AUGMENT_TIMEOUT_MS = 500;
+
+/**
+ * Augment diagnostics with LSP hover and code_actions at the first severity-1 error.
+ * Silently returns null if LSP is unavailable, times out, or there are no errors.
+ */
+export async function augmentDiagnostics(
+  filePath: string,
+  diags: Diagnostic[],
+  manager: LspManager,
+  _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);
+  if (!client) return null;
+
+  const pos = firstError.range.start;
+
+  const [hoverResult, codeActionsResult] = await Promise.all([
+    withTimeout(client.hover(resolvedPath, pos), AUGMENT_TIMEOUT_MS),
+    withTimeout(
+      client.codeActions(resolvedPath, { start: pos, end: pos }, { diagnostics: [firstError] }),
+      AUGMENT_TIMEOUT_MS,
+    ),
+  ]);
+
+  const parts: string[] = [];
+
+  if (hoverResult) {
+    const hoverText = formatHoverForDiagnostics(hoverResult);
+    if (hoverText) parts.push(`💡 Hover info:\n${hoverText}`);
+  }
+
+  if (codeActionsResult && codeActionsResult.length > 0) {
+    const titles = codeActionsResult.map((a) => a.title).join(", ");
+    parts.push(`💡 Available fix: ${titles}`);
+  }
+
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+
+/**
+ * Extract raw hover text for inline diagnostic augmentation.
+ * Intentionally strips markdown code-block framing (unlike formatHover)
+ * to keep augmentation concise and readable inside diagnostic output.
+ */
+function formatHoverForDiagnostics(hover: Hover): string {
+  const contents = hover.contents;
+  let text = "";
+
+  if (typeof contents === "string") {
+    text = contents;
+  } else if ("value" in contents) {
+    const mc = contents as MarkupContent | { language: string; value: string };
+    if ("kind" in mc) text = mc.value;
+    else text = mc.value;
+  } else if (Array.isArray(contents)) {
+    text = (contents as MarkedString[])
+      .map((c) => (typeof c === "string" ? c : c.value))
+      .join("\n");
+  }
+
+  const lines = text.split("\n").slice(0, 3);
+  return lines.join("\n");
+}
+
+async function withTimeout<T>(promise: Promise<T | null>, ms: number): Promise<T | null> {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  const timeoutPromise = new Promise<null>((resolve) => {
+    timer = setTimeout(() => resolve(null), ms);
+  });
+  const result = await Promise.race([promise, timeoutPromise]);
+  if (timer) clearTimeout(timer);
+  return result;
+}

package/node_modules/@mrclrchtr/supi-lsp/src/diagnostics/diagnostic-display.ts

@@ -0,0 +1,68 @@
+import type { OutstandingDiagnosticSummaryEntry } from "../manager/manager-types.ts";
+import type { Diagnostic } from "../types.ts";
+
+export function formatDiagnosticsDisplayContent(
+  diagnostics: OutstandingDiagnosticSummaryEntry[],
+  detailed?: Array<{ file: string; diagnostics: Diagnostic[] }>,
+): string {
+  const totals = collectDisplayTotals(diagnostics);
+  const summary = buildDisplaySummary(totals);
+
+  if (!detailed || detailed.length === 0) return summary;
+
+  const detailLines = buildDisplayDetailLines(detailed);
+  return detailLines.length > 0 ? `${summary}\n${detailLines.join("\n")}` : summary;
+}
+
+function collectDisplayTotals(
+  diagnostics: Array<{ errors: number; warnings: number; information: number; hints: number }>,
+) {
+  return diagnostics.reduce(
+    (acc, d) => ({
+      errors: acc.errors + d.errors,
+      warnings: acc.warnings + d.warnings,
+      information: acc.information + d.information,
+      hints: acc.hints + d.hints,
+    }),
+    { errors: 0, warnings: 0, information: 0, hints: 0 },
+  );
+}
+
+function buildDisplaySummary(totals: {
+  errors: number;
+  warnings: number;
+  information: number;
+  hints: number;
+}): string {
+  const parts: string[] = [];
+  if (totals.errors > 0) parts.push(`${totals.errors} error${totals.errors === 1 ? "" : "s"}`);
+  if (totals.warnings > 0)
+    parts.push(`${totals.warnings} warning${totals.warnings === 1 ? "" : "s"}`);
+  if (totals.information > 0)
+    parts.push(`${totals.information} info${totals.information === 1 ? "" : "s"}`);
+  if (totals.hints > 0) parts.push(`${totals.hints} hint${totals.hints === 1 ? "" : "s"}`);
+
+  return parts.length > 0
+    ? `LSP diagnostics injected (${parts.join(", ")})`
+    : "LSP diagnostics injected";
+}
+
+function buildDisplayDetailLines(
+  detailed: Array<{
+    file: string;
+    diagnostics: Diagnostic[];
+  }>,
+): string[] {
+  const lines: string[] = [];
+  for (const entry of detailed) {
+    for (const d of entry.diagnostics.slice(0, 3)) {
+      const line = d.range.start.line + 1;
+      const source = d.source ? ` ${d.source}` : "";
+      lines.push(`   ${entry.file} L${line}${source}: ${d.message}`);
+    }
+    if (entry.diagnostics.length > 3) {
+      lines.push(`   +${entry.diagnostics.length - 3} more`);
+    }
+  }
+  return lines;
+}

package/node_modules/@mrclrchtr/supi-lsp/src/diagnostics/diagnostic-summary.ts

@@ -0,0 +1,73 @@
+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";
+
+export function collectDiagnosticSummaryCounts(
+  fileDiags: Map<string, { errors: number; warnings: number }>,
+  entry: { uri: string; diagnostics: Diagnostic[] },
+  cwd: string,
+  excludePatterns?: string[],
+): void {
+  const file = relativeFilePathFromUri(entry.uri, cwd);
+  if (shouldIgnoreLspPath(file, cwd)) return;
+  if (excludePatterns?.some((p) => isGlobMatch(file, p))) return;
+
+  const current = fileDiags.get(file) ?? { errors: 0, warnings: 0 };
+  for (const diagnostic of entry.diagnostics) {
+    if (diagnostic.severity === DiagnosticSeverity.Error) current.errors++;
+    else if (diagnostic.severity === DiagnosticSeverity.Warning) current.warnings++;
+  }
+  fileDiags.set(file, current);
+}
+
+export function createOutstandingDiagnosticSummary(
+  file: string,
+): OutstandingDiagnosticSummaryEntry {
+  return {
+    file,
+    total: 0,
+    errors: 0,
+    warnings: 0,
+    information: 0,
+    hints: 0,
+  };
+}
+
+export function accumulateOutstandingDiagnostics(
+  current: OutstandingDiagnosticSummaryEntry,
+  diagnostics: Diagnostic[],
+  maxSeverity: number,
+): OutstandingDiagnosticSummaryEntry {
+  const next = { ...current };
+
+  for (const diagnostic of diagnostics) {
+    if (!isDiagnosticWithinThreshold(diagnostic, maxSeverity)) continue;
+
+    next.total++;
+    incrementOutstandingDiagnosticCount(next, diagnostic.severity);
+  }
+
+  return next;
+}
+
+export function relativeFilePathFromUri(uri: string, cwd: string): string {
+  return displayRelativeFilePath(uri.replace("file://", ""), cwd);
+}
+
+function isDiagnosticWithinThreshold(
+  diagnostic: Diagnostic,
+  maxSeverity: number,
+): diagnostic is Diagnostic & { severity: number } {
+  return diagnostic.severity !== undefined && diagnostic.severity <= maxSeverity;
+}
+
+function incrementOutstandingDiagnosticCount(
+  entry: OutstandingDiagnosticSummaryEntry,
+  severity: number,
+): void {
+  if (severity === DiagnosticSeverity.Error) entry.errors++;
+  else if (severity === DiagnosticSeverity.Warning) entry.warnings++;
+  else if (severity === DiagnosticSeverity.Information) entry.information++;
+  else if (severity === DiagnosticSeverity.Hint) entry.hints++;
+}