@mrclrchtr/supi-code-intelligence 2.0.6 → 2.2.0

package/src/substrate/lsp/settings.ts

@@ -4,22 +4,21 @@
 // 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
+// Uses the declarative settings schema with:
+// - severity: number with labeled values
+// - exclude: stringList
+// - disabled_servers: custom 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 { type ExtensionAPI, getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import type { Component, SettingItem } from "@earendil-works/pi-tui";
 import { Container, Key, matchesKey, SettingsList, Text } from "@earendil-works/pi-tui";
 
-type SettingsScope = "project" | "global";
-
+import { loadSupiConfigSectionForScope, writeSupiConfig } from "@mrclrchtr/supi-core/config";
 import {
-  loadSupiConfigForScope,
-  registerConfigSettings,
-  writeSupiConfig,
-} from "@mrclrchtr/supi-core/config";
+  registerDeclarativeSettings,
+  type SettingsScope,
+  type ValueSource,
+} from "@mrclrchtr/supi-core/settings";
 import { type LspSettings, loadConfig } from "@mrclrchtr/supi-lsp/api";
 
 const LSP_DEFAULTS: LspSettings = {
@@ -29,21 +28,6 @@ const LSP_DEFAULTS: LspSettings = {
   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 {
@@ -59,12 +43,10 @@ function getConfiguredServers(cwd: string): string[] {
  * 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 section = loadSupiConfigSectionForScope("lsp", cwd, {
+    scope,
+  });
+  if (!section) return new Set();
   const servers = section.servers as Record<string, { enabled?: boolean }> | undefined;
   const disabled = new Set<string>();
   if (servers) {
@@ -75,75 +57,11 @@ function getDisabledServersFromConfig(scope: SettingsScope, cwd: string): Set<st
   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,
-) {
+  done: (selectedValue?: string) => void,
+): Component {
   const allServers = getConfiguredServers(cwd);
   const disabledServers = getDisabledServersFromConfig(scope, cwd);
 
@@ -156,14 +74,7 @@ function createDisabledServersSubmenu(
 
   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);
+  container.addChild(new Text("  Disabled Servers — per-language opt-out", 1, 0));
 
   const settingsList = new SettingsList(
     items,
@@ -180,26 +91,22 @@ function createDisabledServersSubmenu(
     { enableSearch: true },
   );
   container.addChild(settingsList);
+  container.addChild(new Text("  esc save and close", 1, 0));
 
   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
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: single event handler for the submenu
     handleInput: (data: string) => {
       if (matchesKey(data, Key.escape)) {
         if (!dirty) {
           done();
-          return true;
+          return;
         }
         // Write per-language enabled/disabled into lsp.servers
-        const currentSection = loadSupiConfigForScope(
-          "lsp",
-          cwd,
-          { servers: {} as Record<string, { enabled?: boolean }> },
-          { scope },
-        );
+        const currentSection = loadSupiConfigSectionForScope("lsp", cwd, { scope });
         const servers =
-          (currentSection.servers as Record<string, Record<string, unknown>> | undefined) ?? {};
+          (currentSection?.servers as Record<string, Record<string, unknown>> | undefined) ?? {};
 
         for (const item of items) {
           if (item.currentValue === "disabled") {
@@ -208,7 +115,6 @@ function createDisabledServersSubmenu(
             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];
               }
@@ -217,70 +123,90 @@ function createDisabledServersSubmenu(
         }
 
         writeSupiConfig({ section: "lsp", scope, cwd }, { servers });
-        done();
-        return true;
+        done("saved");
+        return;
       }
       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);
+export function registerLspSettings(pi: ExtensionAPI): void {
+  registerDeclarativeSettings(pi, {
+    id: "lsp",
+    label: "LSP",
+    section: "lsp",
+    defaults: LSP_DEFAULTS,
+    fields: [
+      {
+        kind: "number" as const,
+        key: "severity",
+        label: "Inline Severity",
+        description: "Minimum diagnostic severity to show inline (1=errors, 4=hints)",
+        values: ["1", "2", "3", "4"],
+      },
+      {
+        kind: "stringList" as const,
+        key: "exclude",
+        label: "Exclude Patterns",
+        description: "Gitignore patterns to suppress LSP diagnostics (comma-separated)",
+      },
+      {
+        kind: "custom" as const,
+        key: "disabled_servers",
+        label: "Disabled Servers",
+        description: "Press Enter to choose which language servers to disable",
+        resolve: (scope, cwd) => {
+          const scopedDisabled = getDisabledServersFromConfig(scope, cwd);
+          const otherScope = scope === "project" ? "global" : "project";
+          const otherDisabled =
+            scope === "project" ? getDisabledServersFromConfig("global", cwd) : new Set<string>();
+
+          // Effective disabled servers = union of both scopes (since either disables)
+          const effectiveDisabled = new Set([...scopedDisabled, ...otherDisabled]);
+          const label =
+            effectiveDisabled.size > 0 ? [...effectiveDisabled].sort().join(", ") : "none disabled";
+
+          // Source: where the override comes from
+          let source: ValueSource;
+          if (scopedDisabled.size > 0) {
+            source = scope;
+          } else if (otherDisabled.size > 0) {
+            source = otherScope as ValueSource;
+          } else {
+            source = "default";
+          }
 
-  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);
+          let inheritanceSource: "global" | "default" | undefined;
+          if (scope === "project" && source === "project") {
+            inheritanceSource =
+              getDisabledServersFromConfig("global", cwd).size > 0 ? "global" : "default";
+          }
 
-  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;
-    },
-  };
+          return { displayValue: label, source, inheritanceSource };
+        },
+        submenu: (_currentValue, done, scope, cwd) =>
+          createDisabledServersSubmenu(scope, cwd, done),
+        // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: custom field persist handler orchestrates nested config writes
+        persist: (scope, cwd, action, _helpers) => {
+          if (action.kind === "inherit" || action.kind === "resetToDefault") {
+            // Clear all per-server enable/disable entries for this scope
+            const currentSection = loadSupiConfigSectionForScope("lsp", cwd, { scope });
+            const servers =
+              (currentSection?.servers as Record<string, Record<string, unknown>> | undefined) ??
+              {};
+            for (const name of Object.keys(servers)) {
+              const srv = servers[name];
+              if (srv) {
+                delete srv.enabled;
+                if (Object.keys(srv).length === 0) delete servers[name];
+              }
+            }
+            writeSupiConfig({ section: "lsp", scope, cwd }, { servers });
+          }
+          // Explicit set actions are handled entirely inside the submenu
+        },
+      },
+    ],
+  });
 }

package/src/tool/find/execute.ts

@@ -16,7 +16,7 @@ import { findModeKindRules } from "../infra/cross-field.ts";
 import { unavailableSearchDetails } from "../infra/error-results.ts";
 import {
   gateSemanticReadiness,
-  resolveScopeParam,
+  resolveScopeSetParam,
   runPipe,
   validateParams,
 } from "../infra/pipeline.ts";
@@ -26,7 +26,7 @@ import { executePattern } from "./orchestrate.ts";
 
 export interface CodeFindToolParams {
   query: string;
-  scope?: string;
+  scope?: string | string[];
   mode?: "text" | "regex" | "ast" | "semantic";
   kind?:
     | "definition"
@@ -43,6 +43,16 @@ export interface CodeFindToolParams {
   maxResults?: number;
 }
 
+interface CodeFindPipelineParams extends CodeFindToolParams {
+  _resolvedScopePaths?: string[];
+  _resolvedScopeDisplay?: string | null;
+}
+
+function scopeForDetails(scope: CodeFindToolParams["scope"]): string | null {
+  if (Array.isArray(scope)) return scope.join(", ");
+  return scope ?? null;
+}
+
 export async function executeFindTool(
   params: CodeFindToolParams,
   ctx: CodeIntelToolExecCtx,
@@ -50,7 +60,7 @@ export async function executeFindTool(
   if (!params.query || params.query.trim().length === 0) {
     return {
       content: "**Error:** `code_find` requires a non-empty `query` parameter.",
-      details: unavailableSearchDetails(params.scope ?? null, [
+      details: unavailableSearchDetails(scopeForDetails(params.scope), [
         "Provide a non-empty `query` parameter",
       ]),
     };
@@ -61,20 +71,22 @@ export async function executeFindTool(
   const mode = params.mode ?? "text";
   const needsSemanticReadiness = mode === "semantic";
 
+  const pipelineParams = params as CodeFindPipelineParams;
+
   return runPipe(
-    params,
+    pipelineParams,
     ctx,
     [
       validateParams(findModeKindRules(), (msg) => ({
         content: msg,
-        details: unavailableSearchDetails(params.scope ?? null, [
+        details: unavailableSearchDetails(scopeForDetails(params.scope), [
           'Use `mode: "ast"` with `kind`, or remove `kind` for text/regex/semantic search',
         ]),
       })),
-      resolveScopeParam((reason) => ({
+      resolveScopeSetParam((reason) => ({
         content: `**Error:** ${reason}`,
-        details: unavailableSearchDetails(params.scope ?? null, [
-          "Verify the `scope` path exists and is within the workspace",
+        details: unavailableSearchDetails(scopeForDetails(params.scope), [
+          "Verify each `scope` path exists and is within the workspace",
         ]),
       })),
       ...(needsSemanticReadiness
@@ -82,7 +94,7 @@ export async function executeFindTool(
             gateSemanticReadiness("code_find", {
               onTimeout: () => ({
                 content: renderSemanticReadinessTimeout("code_find", 15_000),
-                details: unavailableSearchDetails(params.scope ?? null, [
+                details: unavailableSearchDetails(scopeForDetails(params.scope), [
                   "Retry shortly or check `code_health`",
                 ]),
               }),
@@ -104,7 +116,8 @@ export async function executeFindTool(
       return executePattern(
         {
           pattern: p.query,
-          path: p.scope ?? c.cwd,
+          paths: p._resolvedScopePaths ?? [c.cwd],
+          scopeLabel: p._resolvedScopeDisplay ?? null,
           regex: mode === "regex",
           kind: p.kind,
           mode,