@mrclrchtr/supi-lsp 0.1.0 → 1.1.2

package/node_modules/@mrclrchtr/supi-core/src/settings-ui.ts

@@ -0,0 +1,226 @@
+// Generic settings overlay for SuPi extensions.
+//
+// Uses pi-tui's SettingsList with scope toggle (Tab), extension grouping,
+// and search. Each extension declares its settings via registerSettings().
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import {
+  Container,
+  Input,
+  Key,
+  matchesKey,
+  type SettingItem,
+  SettingsList,
+  Text,
+} from "@earendil-works/pi-tui";
+import {
+  getRegisteredSettings,
+  type SettingsScope,
+  type SettingsSection,
+} from "./settings-registry.ts";
+
+// ── Input submenu component ──────────────────────────────────
+
+/**
+ * Creates a pi-tui Input-backed submenu component with enter-to-confirm
+ * and escape-to-cancel handling.
+ *
+ * @param currentValue - Initial value for the text input.
+ * @param label - Label text displayed above the input.
+ * @param done - Callback invoked with the confirmed value, or undefined on cancel.
+ */
+export function createInputSubmenu(
+  currentValue: string,
+  label: string,
+  done: (selectedValue?: string) => void,
+): {
+  render: (width: number) => string[];
+  invalidate: () => void;
+  handleInput: (data: string) => boolean;
+} {
+  const input = new Input();
+  input.setValue(currentValue);
+
+  return {
+    render: (_width: number) => {
+      const lines = [`  ${label}`];
+      lines.push(...input.render(_width));
+      lines.push("  enter confirm • esc cancel");
+      return lines;
+    },
+    invalidate: () => {
+      input.invalidate();
+    },
+    handleInput: (data: string) => {
+      if (matchesKey(data, Key.escape)) {
+        done();
+        return true;
+      }
+      if (matchesKey(data, Key.enter)) {
+        done(input.getValue());
+        return true;
+      }
+      input.handleInput(data);
+      return true;
+    },
+  };
+}
+
+// ── Types ────────────────────────────────────────────────────
+
+interface OverlayState {
+  scope: SettingsScope;
+  cwd: string;
+}
+
+// ── Pure helpers ─────────────────────────────────────────────
+
+function getScopeLabel(scope: SettingsScope): string {
+  return scope === "project" ? "Project" : "Global";
+}
+
+function buildFlatItems(
+  sections: SettingsSection[],
+  scope: SettingsScope,
+  cwd: string,
+): SettingItem[] {
+  const items: SettingItem[] = [];
+  for (const section of sections) {
+    const sectionItems = section.loadValues(scope, cwd);
+    for (const item of sectionItems) {
+      items.push({
+        ...item,
+        id: `${section.id}.${item.id}`,
+        label: `${section.label}: ${item.label}`,
+      });
+    }
+  }
+  return items;
+}
+
+function findSectionAndId(
+  sections: SettingsSection[],
+  flatId: string,
+): { section: SettingsSection; itemId: string } | null {
+  const dotIndex = flatId.indexOf(".");
+  if (dotIndex === -1) return null;
+  const sectionId = flatId.slice(0, dotIndex);
+  const itemId = flatId.slice(dotIndex + 1);
+  const section = sections.find((s) => s.id === sectionId);
+  if (!section) return null;
+  return { section, itemId };
+}
+
+// ── Component ────────────────────────────────────────────────
+
+interface SettingsOverlayDeps {
+  state: OverlayState;
+  container: Container;
+  settingsList: SettingsList | null;
+  tui: Parameters<Parameters<ExtensionContext["ui"]["custom"]>[0]>[0];
+  theme: Parameters<Parameters<ExtensionContext["ui"]["custom"]>[0]>[1];
+  done: () => void;
+}
+
+function createSettingsList(deps: SettingsOverlayDeps): SettingsList {
+  const sections = getRegisteredSettings();
+  const items = buildFlatItems(sections, deps.state.scope, deps.state.cwd);
+  const onChange = (flatId: string, newValue: string) => {
+    const found = findSectionAndId(sections, flatId);
+    if (found) {
+      found.section.persistChange(deps.state.scope, deps.state.cwd, found.itemId, newValue);
+    }
+    // Re-read all values to reflect persisted changes, but keep the list
+    // instance (and its selectedIndex) intact.
+    const updatedItems = buildFlatItems(sections, deps.state.scope, deps.state.cwd);
+    for (const updated of updatedItems) {
+      const existing = items.find((i) => i.id === updated.id);
+      if (existing && existing.currentValue !== updated.currentValue) {
+        settingsList.updateValue(updated.id, updated.currentValue);
+      }
+    }
+    deps.tui.requestRender();
+  };
+  const settingsList = new SettingsList(
+    items,
+    Math.min(items.length + 4, 20),
+    getSettingsListTheme(),
+    onChange,
+    () => deps.done(),
+    { enableSearch: true },
+  );
+  return settingsList;
+}
+
+function rebuildSettingsList(deps: SettingsOverlayDeps): SettingsList {
+  const settingsList = createSettingsList(deps);
+  deps.settingsList = settingsList;
+
+  deps.container.clear();
+  deps.container.addChild(createHeaderComponent(deps));
+  deps.container.addChild(settingsList);
+
+  return settingsList;
+}
+
+function createHeaderComponent(deps: SettingsOverlayDeps): Text {
+  const { theme, state } = deps;
+  const scopeLabel = getScopeLabel(state.scope);
+  const otherScope = state.scope === "project" ? "Global" : "Project";
+  const headerText = new Text(
+    `${theme.fg("accent", theme.bold("SuPi Settings"))}  ${theme.fg("text", `Scope: ${scopeLabel}`)} ${theme.fg("dim", `(tab → ${otherScope})`)}`,
+    0,
+    0,
+  );
+  return headerText;
+}
+
+function handleScopeToggle(deps: SettingsOverlayDeps): void {
+  deps.state.scope = deps.state.scope === "project" ? "global" : "project";
+  rebuildSettingsList(deps);
+  deps.tui.requestRender();
+}
+
+// ── Entry point ──────────────────────────────────────────────
+
+export function openSettingsOverlay(ctx: ExtensionContext): void {
+  const sections = getRegisteredSettings();
+  if (sections.length === 0) {
+    ctx.ui.notify("No settings registered by SuPi extensions", "info");
+    return;
+  }
+
+  void ctx.ui.custom<void>((tui, theme, _kb, done) => {
+    const state: OverlayState = { scope: "project", cwd: ctx.cwd };
+    const container = new Container();
+
+    const deps: SettingsOverlayDeps = {
+      state,
+      container,
+      settingsList: null,
+      tui,
+      theme,
+      done,
+    };
+
+    rebuildSettingsList(deps);
+
+    const component = {
+      render: (width: number) => container.render(width),
+      invalidate: () => container.invalidate(),
+      handleInput: (data: string) => {
+        if (matchesKey(data, Key.tab)) {
+          handleScopeToggle(deps);
+          return true;
+        }
+        // Delegate input to the settings list (always set after rebuildSettingsList)
+        deps.settingsList?.handleInput?.(data);
+        deps.tui.requestRender();
+        return true;
+      },
+    };
+
+    return component;
+  });
+}

package/node_modules/@mrclrchtr/supi-core/src/terminal.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared terminal title formatting and signaling utilities.
+ *
+ * Centralized place for pi title convention (π prefix), completion (✓)
+ * and waiting (●) indicators, and the audible terminal bell.
+ */
+import path from "node:path";
+
+/** Unicode checkmark shown when the agent finishes a turn. */
+export const DONE_SYMBOL = "\u2713";
+/** Unicode dot shown when waiting for user input. */
+export const WAITING_SYMBOL = "\u25CF";
+
+/** Minimal UI surface needed for title operations. */
+export interface TitleTarget {
+  ui: {
+    setTitle?(title: string): void;
+  };
+}
+
+/**
+ * Format pi's canonical terminal title from session name and cwd.
+ * Falls back gracefully when either is missing.
+ *
+ * @example
+ *   formatTitle("my-session", "/home/projects/foo")  // "π - my-session - foo"
+ *   formatTitle(undefined, "/home/projects/foo")      // "π - foo"
+ *   formatTitle("my-session")                         // "π - my-session"
+ *   formatTitle()                                     // "π"
+ */
+export function formatTitle(sessionName?: string, cwd?: string): string {
+  const base = cwd ? path.basename(cwd) : undefined;
+  if (sessionName && base) return `π - ${sessionName} - ${base}`;
+  if (sessionName) return `π - ${sessionName}`;
+  if (base) return `π - ${base}`;
+  return "π";
+}
+
+/** Sound the audible terminal bell (ASCII BEL). */
+export function signalBell(): void {
+  process.stdout.write("\x07");
+}
+
+/**
+ * Set the terminal title to indicate the agent is waiting for user input.
+ * Prefixes with ● and sounds the terminal bell.
+ */
+export function signalWaiting(ctx: TitleTarget, title: string): void {
+  ctx.ui.setTitle?.(`${WAITING_SYMBOL}  ${title}`);
+  signalBell();
+}
+
+/**
+ * Set the terminal title to indicate the agent turn has completed.
+ * Prefixes with ✓ and sounds the terminal bell.
+ */
+export function signalDone(ctx: TitleTarget, title: string): void {
+  ctx.ui.setTitle?.(`${DONE_SYMBOL} ${title}`);
+  signalBell();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "0.1.0",
+  "version": "1.1.2",
   "description": "SuPi LSP extension — Language Server Protocol integration for pi",
   "license": "MIT",
   "repository": {
@@ -16,21 +16,26 @@
     "pi-coding-agent"
   ],
   "files": [
-    "*.ts",
-    "*.json",
+    "src/**/*.ts",
+    "src/**/*.json",
     "!__tests__"
   ],
-  "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "~0.66.0",
-    "@mariozechner/pi-tui": "~0.66.0",
-    "@sinclair/typebox": ">=0.34.0"
+  "dependencies": {
+    "@mrclrchtr/supi-core": "1.1.2"
   },
-  "devDependencies": {
-    "vitest": "^4.1.4"
+  "bundledDependencies": [
+    "@mrclrchtr/supi-core"
+  ],
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   },
   "pi": {
     "extensions": [
-      "./lsp.ts"
+      "./src/lsp.ts"
     ]
-  }
+  },
+  "main": "src/index.ts"
 }

package/{capabilities.ts → src/capabilities.ts}

@@ -46,9 +46,17 @@ export const CLIENT_CAPABILITIES: ClientCapabilities = {
     },
     publishDiagnostics: {
       relatedInformation: true,
+      versionSupport: true,
+    },
+    diagnostic: {
+      dynamicRegistration: false,
+      relatedDocumentSupport: true,
     },
   },
   workspace: {
     workspaceFolders: false,
+    diagnostics: {
+      refreshSupport: false,
+    },
   },
 };

package/src/client/client-refresh.ts

@@ -0,0 +1,229 @@
+// LSP Client diagnostic refresh — pull diagnostics and push settle logic.
+// Extracted from client.ts to keep file sizes manageable.
+
+import { existsSync, readFileSync } from "node:fs";
+import type { DocumentDiagnosticReport, TextDocumentIdentifier } from "../types.ts";
+import { uriToFile } from "../utils.ts";
+import type { DiagnosticCacheEntry, LspClient } from "./client.ts";
+import type { JsonRpcClient } from "./transport.ts";
+
+interface ClientAccess {
+  openDocs: Map<string, { version: number; languageId: string }>;
+  rpc: JsonRpcClient | null;
+  diagnosticStore: Map<string, DiagnosticCacheEntry>;
+  releaseDiagnosticWaiters(uri: string): void;
+}
+
+function accessClient(client: LspClient): ClientAccess {
+  return client as unknown as ClientAccess;
+}
+
+/**
+ * Re-read and re-sync all currently open, existing documents for a client.
+ * Uses pull diagnostics when the server supports them, otherwise falls back
+ * to push-diagnostic settling. Never throws.
+ */
+export async function refreshClientOpenDiagnostics(
+  client: LspClient,
+  options: { maxWaitMs?: number; quietMs?: number } = {},
+): Promise<void> {
+  const maxWaitMs = options.maxWaitMs ?? 3_000;
+  const quietMs = options.quietMs ?? 200;
+
+  if (client.status !== "running") return;
+
+  const syncStart = Date.now();
+
+  // Re-sync all open documents that still exist on disk
+  const openDocs = accessClient(client).openDocs as Map<
+    string,
+    { version: number; languageId: string }
+  >;
+
+  for (const [uri, doc] of openDocs) {
+    const filePath = uriToFile(uri);
+    try {
+      if (!existsSync(filePath)) {
+        clearFileState(client, uri);
+        sendNotification(client, "textDocument/didClose", {
+          textDocument: { uri } satisfies TextDocumentIdentifier,
+        });
+        continue;
+      }
+      const content = readFileSync(filePath, "utf-8");
+      doc.version++;
+      sendDidChange(client, uri, doc.version, content);
+    } catch {
+      // Read error — skip this file, keep it open
+    }
+  }
+
+  if (openDocs.size === 0) return;
+
+  // Try pull diagnostics if server supports them
+  if (client.hasDiagnosticProvider) {
+    try {
+      await pullDiagnosticsForOpenDocs(client, syncStart, maxWaitMs);
+      return;
+    } catch {
+      // Pull diagnostics failed — fall back to push settle
+    }
+  }
+
+  // Fall back to push-diagnostic settling
+  await waitForDiagnosticSettle(client, syncStart, maxWaitMs, quietMs);
+}
+
+/** Send a didChange notification through the client's RPC. */
+function sendDidChange(client: LspClient, uri: string, version: number, content: string): void {
+  sendNotification(client, "textDocument/didChange", {
+    textDocument: { uri, version },
+    contentChanges: [{ text: content }],
+  });
+}
+
+/** Send an RPC notification through the client. */
+function sendNotification(client: LspClient, method: string, params: unknown): void {
+  const rpc = accessClient(client).rpc;
+  if (rpc) rpc.sendNotification(method, params);
+}
+
+/** Clear open doc and diagnostic state for a URI. */
+function clearFileState(client: LspClient, uri: string): void {
+  accessClient(client).openDocs.delete(uri);
+  accessClient(client).diagnosticStore.delete(uri);
+  accessClient(client).releaseDiagnosticWaiters(uri);
+}
+
+/**
+ * Request pull diagnostics for all open documents.
+ * Throws if no diagnostics were successfully retrieved.
+ */
+async function pullDiagnosticsForOpenDocs(
+  client: LspClient,
+  syncStart: number,
+  maxWaitMs: number,
+): Promise<void> {
+  const deadline = syncStart + maxWaitMs;
+  const uris = Array.from((accessClient(client).openDocs as Map<string, unknown>).keys());
+  const results = await Promise.allSettled(
+    uris.map(async (uri) => {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) throw new Error("pull diagnostic timeout");
+
+      return pullDiagnosticsForUri(client, uri, remaining);
+    }),
+  );
+
+  const anySuccess = results.some((result) => result.status === "fulfilled" && result.value);
+  const hadFailure = results.some((result) => result.status === "rejected");
+
+  if ((hadFailure || !anySuccess) && uris.length > 0) {
+    throw new Error("pull diagnostics incomplete");
+  }
+}
+
+/** Pull diagnostics for a single URI and apply the report to the cache. */
+export async function pullDiagnosticsForUri(
+  client: LspClient,
+  uri: string,
+  timeoutMs: number,
+): Promise<boolean> {
+  const report = await pullDocumentDiagnostics(client, uri, timeoutMs);
+  if (!report) return false;
+  applyPullReport(client, uri, report);
+  return true;
+}
+
+/** Pull diagnostics for a single document with timeout. */
+async function pullDocumentDiagnostics(
+  client: LspClient,
+  uri: string,
+  timeoutMs: number,
+): Promise<DocumentDiagnosticReport | null> {
+  const rpc = accessClient(client).rpc;
+  if (!rpc || client.status !== "running") {
+    throw new Error("client not running");
+  }
+
+  const previousResultId = accessClient(client).diagnosticStore.get(uri)?.resultId;
+  return rpc.sendRequest(
+    "textDocument/diagnostic",
+    {
+      textDocument: { uri },
+      previousResultId,
+    },
+    { timeoutMs },
+  ) as Promise<DocumentDiagnosticReport>;
+}
+
+/** Apply a pull diagnostic report to the cache, including related documents. */
+function applyPullReport(client: LspClient, uri: string, report: DocumentDiagnosticReport): void {
+  if (report.kind === "full") {
+    accessClient(client).diagnosticStore.set(uri, {
+      diagnostics: report.items,
+      receivedAt: Date.now(),
+      resultId: report.resultId,
+    });
+  } else if (report.kind === "unchanged" && report.resultId) {
+    const current = accessClient(client).diagnosticStore.get(uri);
+    if (current) current.resultId = report.resultId;
+  }
+
+  applyRelatedDocuments(client, report);
+}
+
+/** Extract and store related document diagnostics from a pull report. */
+function applyRelatedDocuments(client: LspClient, report: DocumentDiagnosticReport): void {
+  const related = (report as unknown as Record<string, unknown>).relatedDocuments;
+  if (!related || typeof related !== "object") return;
+
+  for (const [relatedUri, relatedReport] of Object.entries(
+    related as Record<string, DocumentDiagnosticReport>,
+  )) {
+    if (relatedReport.kind === "full" && relatedReport.items) {
+      accessClient(client).diagnosticStore.set(relatedUri, {
+        diagnostics: relatedReport.items,
+        receivedAt: Date.now(),
+        resultId: relatedReport.resultId,
+      });
+    }
+  }
+}
+
+/**
+ * Wait until no publishDiagnostics notifications arrive for quietMs
+ * after syncStart, or until maxWaitMs elapses.
+ */
+async function waitForDiagnosticSettle(
+  client: LspClient,
+  syncStart: number,
+  maxWaitMs: number,
+  quietMs: number,
+): Promise<void> {
+  const deadline = syncStart + maxWaitMs;
+
+  while (Date.now() < deadline) {
+    const lastReceived = lastDiagnosticReceivedTimeAfter(client, syncStart) || syncStart;
+    const elapsed = Date.now() - lastReceived;
+    if (elapsed >= quietMs) {
+      return;
+    }
+
+    await new Promise((resolve) =>
+      setTimeout(resolve, Math.min(quietMs - elapsed, deadline - Date.now(), 50)),
+    );
+  }
+}
+
+/** Get the most recent receivedAt timestamp after a given time. */
+function lastDiagnosticReceivedTimeAfter(client: LspClient, afterTime: number): number {
+  let latest = 0;
+  const store = accessClient(client).diagnosticStore as Map<string, { receivedAt: number }>;
+  for (const entry of store.values()) {
+    if (entry.receivedAt > afterTime && entry.receivedAt > latest) {
+      latest = entry.receivedAt;
+    }
+  }
+  return latest;
+}