@mrclrchtr/supi-code-intelligence 1.16.0 → 2.0.0

package/src/substrate/lsp/settings.ts

@@ -0,0 +1,286 @@
+// LSP settings registration for the code-intelligence umbrella extension.
+//
+// Always-on LSP policy: the global `lsp.enabled` and `lsp.active` keys
+// are deprecated and ignored. Per-language disable via
+// `lsp.servers.<language>.enabled: false` is the only supported opt-out.
+//
+// This settings section provides:
+// - severity control
+// - excluded patterns
+// - a "Disabled Servers" submenu that writes per-language disable config
+
+import { CONFIG_DIR_NAME, getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import type { SettingItem } from "@earendil-works/pi-tui";
+import { Container, Key, matchesKey, SettingsList, Text } from "@earendil-works/pi-tui";
+
+type SettingsScope = "project" | "global";
+
+import {
+  loadSupiConfigForScope,
+  registerConfigSettings,
+  writeSupiConfig,
+} from "@mrclrchtr/supi-core/config";
+import { type LspSettings, loadConfig } from "@mrclrchtr/supi-lsp/api";
+
+const LSP_DEFAULTS: LspSettings = {
+  enabled: true,
+  severity: 1,
+  active: [],
+  exclude: [],
+};
+
+function severityLabel(severity: number): string {
+  switch (severity) {
+    case 1:
+      return "errors";
+    case 2:
+      return "warnings";
+    case 3:
+      return "info";
+    case 4:
+      return "hints";
+    default:
+      return "errors";
+  }
+}
+
+/** Discover configured servers from the defaults + effective LSP config. */
+function getConfiguredServers(cwd: string): string[] {
+  try {
+    const config = loadConfig(cwd);
+    return Object.keys(config.servers);
+  } catch {
+    return ["typescript"];
+  }
+}
+
+/**
+ * Load the raw LSP section for a single scope to inspect the currently
+ * configured disabled servers from the persisted config.
+ */
+function getDisabledServersFromConfig(scope: SettingsScope, cwd: string): Set<string> {
+  const section = loadSupiConfigForScope(
+    "lsp",
+    cwd,
+    { servers: {} as Record<string, { enabled?: boolean }> },
+    { scope },
+  );
+  const servers = section.servers as Record<string, { enabled?: boolean }> | undefined;
+  const disabled = new Set<string>();
+  if (servers) {
+    for (const [name, srv] of Object.entries(servers)) {
+      if (srv.enabled === false) disabled.add(name);
+    }
+  }
+  return disabled;
+}
+
+export function registerLspSettings(): void {
+  registerConfigSettings({
+    id: "lsp",
+    label: "LSP",
+    section: "lsp",
+    defaults: LSP_DEFAULTS,
+    buildItems: (settings, scope, cwd) => buildLspSettingItems(settings, scope, cwd),
+    // biome-ignore lint/complexity/useMaxParams: registerConfigSettings callback signature
+    persistChange: (_scope, _cwd, settingId, value, helpers) => {
+      switch (settingId) {
+        case "severity": {
+          const num = Number.parseInt(value.split(" ")[0] ?? "1", 10);
+          helpers.set("severity", Number.isNaN(num) ? 1 : num);
+          break;
+        }
+        case "exclude": {
+          const patterns = value
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+          if (patterns.length > 0) helpers.set("exclude", patterns);
+          else helpers.unset("exclude");
+          break;
+        }
+      }
+    },
+  });
+}
+
+function buildLspSettingItems(
+  settings: LspSettings,
+  scope: "project" | "global",
+  cwd: string,
+): SettingItem[] {
+  return [
+    {
+      id: "severity",
+      label: "Inline Severity",
+      description: "Minimum diagnostic severity to show inline (1=errors, 4=hints)",
+      currentValue: `${settings.severity} (${severityLabel(settings.severity)})`,
+      values: ["1 (errors)", "2 (warnings)", "3 (info)", "4 (hints)"],
+    },
+    {
+      id: "disabled_servers",
+      label: "Disabled Servers",
+      description: "Press Enter to choose which language servers to disable",
+      currentValue: renderDisabledServersLabel(scope, cwd),
+      submenu: (_currentValue, done) => createDisabledServersSubmenu(scope, cwd, done),
+    },
+    {
+      id: "exclude",
+      label: "Exclude Patterns",
+      description: "Gitignore patterns to suppress LSP diagnostics",
+      currentValue: settings.exclude.length > 0 ? settings.exclude.join(", ") : "none",
+      submenu: (_currentValue, done) => createExcludeSubmenu(scope, cwd, settings, done),
+    },
+  ];
+}
+
+function renderDisabledServersLabel(scope: SettingsScope, cwd: string): string {
+  const disabled = getDisabledServersFromConfig(scope, cwd);
+  return disabled.size > 0 ? [...disabled].sort().join(", ") : "none disabled";
+}
+
+function createDisabledServersSubmenu(
+  scope: SettingsScope,
+  cwd: string,
+  done: (value?: string) => void,
+) {
+  const allServers = getConfiguredServers(cwd);
+  const disabledServers = getDisabledServersFromConfig(scope, cwd);
+
+  const items: SettingItem[] = allServers.map((name) => ({
+    id: name,
+    label: name,
+    currentValue: disabledServers.has(name) ? "disabled" : "enabled",
+    values: ["enabled", "disabled"],
+  }));
+
+  let dirty = false;
+  const container = new Container();
+  const header = new Text("Disabled Servers — per-language opt-out", 0, 0);
+  container.addChild(header);
+  const footer = new Text(
+    "Marking a server as disabled writes lsp.servers.<lang>.enabled: false for this scope",
+    0,
+    0,
+  );
+  container.addChild(footer);
+
+  const settingsList = new SettingsList(
+    items,
+    Math.min(items.length + 3, 15),
+    getSettingsListTheme(),
+    (id, newValue) => {
+      const idx = items.findIndex((i) => i.id === id);
+      if (idx >= 0 && items[idx].currentValue !== newValue) {
+        dirty = true;
+        items[idx].currentValue = newValue;
+      }
+    },
+    () => {},
+    { enableSearch: true },
+  );
+  container.addChild(settingsList);
+
+  return {
+    render: (width: number) => container.render(width),
+    invalidate: () => container.invalidate(),
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: single event handler dispatching keyboard shortcuts for the Disabled Servers submenu
+    handleInput: (data: string) => {
+      if (matchesKey(data, Key.escape)) {
+        if (!dirty) {
+          done();
+          return true;
+        }
+        // Write per-language enabled/disabled into lsp.servers
+        const currentSection = loadSupiConfigForScope(
+          "lsp",
+          cwd,
+          { servers: {} as Record<string, { enabled?: boolean }> },
+          { scope },
+        );
+        const servers =
+          (currentSection.servers as Record<string, Record<string, unknown>> | undefined) ?? {};
+
+        for (const item of items) {
+          if (item.currentValue === "disabled") {
+            servers[item.id] = { ...(servers[item.id] ?? {}), enabled: false };
+          } else {
+            const srv = servers[item.id];
+            if (srv) {
+              delete srv.enabled;
+              // If only `enabled` was the property, remove the whole entry
+              if (Object.keys(srv).length === 0) {
+                delete servers[item.id];
+              }
+            }
+          }
+        }
+
+        writeSupiConfig({ section: "lsp", scope, cwd }, { servers });
+        done();
+        return true;
+      }
+      settingsList.handleInput?.(data);
+      return true;
+    },
+  };
+}
+
+function createExcludeSubmenu(
+  _scope: "project" | "global",
+  _cwd: string,
+  settings: LspSettings,
+  done: (value?: string) => void,
+) {
+  const items: SettingItem[] = settings.exclude.map((pattern) => ({
+    id: pattern,
+    label: pattern,
+    currentValue: "enabled",
+    values: ["enabled", "disabled"],
+  }));
+
+  let dirty = false;
+  const container = new Container();
+  const header = new Text("Exclude Patterns — toggle off to remove", 0, 0);
+  container.addChild(header);
+
+  const footer = new Text(
+    `Add new patterns in ${CONFIG_DIR_NAME}/supi/config.json under lsp.exclude`,
+    0,
+    0,
+  );
+  container.addChild(footer);
+
+  const settingsList = new SettingsList(
+    items,
+    Math.min(items.length + 3, 15),
+    getSettingsListTheme(),
+    (id, newValue) => {
+      const idx = items.findIndex((i) => i.id === id);
+      if (idx >= 0 && items[idx].currentValue !== newValue) {
+        dirty = true;
+        items[idx].currentValue = newValue;
+      }
+    },
+    () => {},
+  );
+  container.addChild(settingsList);
+
+  return {
+    render: (width: number) => container.render(width),
+    invalidate: () => container.invalidate(),
+    handleInput: (data: string) => {
+      if (matchesKey(data, Key.escape)) {
+        if (!dirty) {
+          done();
+          return true;
+        }
+        const enabled = items.filter((i) => i.currentValue === "enabled").map((i) => i.id);
+        done(enabled.join(", ") || undefined);
+        return true;
+      }
+      settingsList.handleInput?.(data);
+      return true;
+    },
+  };
+}

package/src/substrate/lsp/state.ts

@@ -0,0 +1,46 @@
+// Umbrella LSP adapter state for supi-code-intelligence.
+//
+// Mirrors the shape of supi-lsp's LspRuntimeState but owns its lifecycle
+// through LspRuntimeController from @mrclrchtr/supi-lsp/api.
+
+import type { LspRuntimeController } from "@mrclrchtr/supi-lsp/api";
+
+/** LSP status overlay UI state (handle + close). */
+export interface LspInspectorState {
+  handle: (() => void) | null;
+  close: (() => void) | null;
+}
+
+/**
+ * In-memory state for the umbrella LSP adapter.
+ *
+ * Wraps the LspRuntimeController and tracks session-level state
+ * for diagnostic injection, stale detection, and UI updates.
+ */
+export interface LspAdapterState {
+  controller: LspRuntimeController | null;
+  inlineSeverity: number;
+  inspector: LspInspectorState;
+  lastDiagnosticsFingerprint: string | null;
+  currentContextToken: string | null;
+  contextCounter: number;
+  lspActive: boolean;
+  staleSuspected: boolean;
+  lastWorkspaceChangeAt: number;
+  sentinelSnapshot: Map<string, number>;
+}
+
+export function createLspAdapterState(): LspAdapterState {
+  return {
+    controller: null,
+    inlineSeverity: 1,
+    inspector: { handle: null, close: null },
+    lastDiagnosticsFingerprint: null,
+    currentContextToken: null,
+    contextCounter: 0,
+    lspActive: false,
+    staleSuspected: false,
+    lastWorkspaceChangeAt: 0,
+    sentinelSnapshot: new Map(),
+  };
+}

package/src/substrate/lsp/utils.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared utilities for working with LSP Diagnostic types.
+ *
+ * vscode-languageserver-types v3.18.0 widened Diagnostic.message from
+ * `string` to `string | MarkupContent`. Use these helpers to safely
+ * extract the string representation without repeating the cast.
+ */
+
+import type { Diagnostic } from "@mrclrchtr/supi-lsp/api";
+
+/**
+ * Return the plain-text message from a Diagnostic, handling both
+ * the legacy `string` and new `MarkupContent` forms.
+ */
+export function diagnosticMessageString(d: Diagnostic): string {
+  return typeof d.message === "string" ? d.message : d.message.value;
+}

package/src/substrate/tree-sitter/lifecycle.ts

@@ -0,0 +1,52 @@
+// Tree-sitter session lifecycle — uses TreeSitterRuntimeController from @mrclrchtr/supi-tree-sitter/api.
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
+import { TreeSitterRuntimeController } from "@mrclrchtr/supi-tree-sitter/api";
+
+/**
+ * Tree-sitter adapter state for the umbrella extension.
+ */
+export interface TsAdapterState {
+  controller: TreeSitterRuntimeController | null;
+}
+
+export function createTsAdapterState(): TsAdapterState {
+  return { controller: null };
+}
+
+/**
+ * Register Tree-sitter session lifecycle handlers.
+ *
+ * - session_start: creates TreeSitterRuntimeController, starts it, registers tools
+ * - session_shutdown: shuts down the controller
+ */
+export function registerTsSessionLifecycle(pi: ExtensionAPI, state: TsAdapterState): void {
+  pi.on("session_start", async (_event, ctx: ExtensionContext) => {
+    const cwd = ctx.cwd;
+    const runtime = getDefaultWorkspaceRuntime();
+
+    // Shut down any existing controller
+    if (state.controller) {
+      await state.controller.shutdown();
+      state.controller = null;
+    }
+
+    const controller = new TreeSitterRuntimeController(cwd, runtime);
+    const result = await controller.start();
+
+    if (result.kind === "ready") {
+      state.controller = controller;
+    } else {
+      await controller.shutdown();
+      state.controller = null;
+    }
+  });
+
+  pi.on("session_shutdown", async () => {
+    if (state.controller) {
+      await state.controller.shutdown();
+      state.controller = null;
+    }
+  });
+}

package/src/tool/find/execute.ts

@@ -0,0 +1,118 @@
+/**
+ * Tool executor for code_find.
+ *
+ * Unified ranked code search with strict mode dispatch:
+ * - text (default): literal ripgrep
+ * - regex: ripgrep regex
+ * - ast: tree-sitter structured search
+ * - semantic: LSP workspace symbols
+ *
+ * Thin executor: validates params via pipeline, then delegates all
+ * modes to the pattern use-case.
+ */
+
+import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
+import { findModeKindRules } from "../infra/cross-field.ts";
+import { unavailableSearchDetails } from "../infra/error-results.ts";
+import {
+  gateSemanticReadiness,
+  resolveScopeParam,
+  runPipe,
+  validateParams,
+} from "../infra/pipeline.ts";
+import { emitToolProgress } from "../infra/progress.ts";
+import { renderSemanticReadinessTimeout } from "../infra/readiness-message.ts";
+import { executePattern } from "./orchestrate.ts";
+
+export interface CodeFindToolParams {
+  query: string;
+  scope?: string;
+  mode?: "text" | "regex" | "ast" | "semantic";
+  kind?:
+    | "definition"
+    | "import"
+    | "export"
+    | "call"
+    | "type"
+    | "interface"
+    | "class"
+    | "method"
+    | "enum"
+    | "test";
+  contextLines?: number;
+  maxResults?: number;
+}
+
+export async function executeFindTool(
+  params: CodeFindToolParams,
+  ctx: CodeIntelToolExecCtx,
+): Promise<CodeIntelResult> {
+  if (!params.query || params.query.trim().length === 0) {
+    return {
+      content: "**Error:** `code_find` requires a non-empty `query` parameter.",
+      details: unavailableSearchDetails(params.scope ?? null, [
+        "Provide a non-empty `query` parameter",
+      ]),
+    };
+  }
+
+  emitToolProgress(ctx.onUpdate, `code_find: searching for "${params.query}"...`);
+
+  const mode = params.mode ?? "text";
+  const needsSemanticReadiness = mode === "semantic";
+
+  return runPipe(
+    params,
+    ctx,
+    [
+      validateParams(findModeKindRules(), (msg) => ({
+        content: msg,
+        details: unavailableSearchDetails(params.scope ?? null, [
+          'Use `mode: "ast"` with `kind`, or remove `kind` for text/regex/semantic search',
+        ]),
+      })),
+      resolveScopeParam((reason) => ({
+        content: `**Error:** ${reason}`,
+        details: unavailableSearchDetails(params.scope ?? null, [
+          "Verify the `scope` path exists and is within the workspace",
+        ]),
+      })),
+      ...(needsSemanticReadiness
+        ? [
+            gateSemanticReadiness("code_find", {
+              onTimeout: () => ({
+                content: renderSemanticReadinessTimeout("code_find", 15_000),
+                details: unavailableSearchDetails(params.scope ?? null, [
+                  "Retry shortly or check `code_health`",
+                ]),
+              }),
+              throwOnUnavailable: true,
+            }),
+          ]
+        : []),
+    ],
+    async (p, c) => {
+      emitToolProgress(c.onUpdate, `code_find: ${mode} mode...`);
+
+      // AST mode requires structural provider
+      if (mode === "ast" && !c.session.getStructuralProvider()) {
+        throw new Error(
+          "code_find AST search is unavailable because no structural/tree-sitter provider is active for this workspace.",
+        );
+      }
+
+      return executePattern(
+        {
+          pattern: p.query,
+          path: p.scope ?? c.cwd,
+          regex: mode === "regex",
+          kind: p.kind,
+          mode,
+          maxResults: p.maxResults ?? 8,
+          contextLines: p.contextLines ?? 1,
+        },
+        { cwd: c.cwd, provider: c.session.getProvider(), signal: c.signal },
+      );
+    },
+  );
+}