@mrclrchtr/supi-lsp 2.1.0 → 2.2.0

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/README.md

@@ -39,14 +39,17 @@ Config file locations:
 
 ### Settings helpers
 
-- `registerConfigSettings(pi, options)` — contribute a config-backed settings section with scoped persistence helpers
+- `registerDeclarativeSettings(pi, options)` — contribute a config-backed declarative settings section with source-aware scoped persistence
 - `registerSettingsCommand(pi)` — register `/supi-settings` (used by `@mrclrchtr/supi-settings`)
 - `openSettingsOverlay(pi, ctx)` — open the shared settings UI directly
 - `createInputSubmenu()` — helper for simple text-entry submenus
+- `createModelPickerSubmenu()` — helper for scoped model selection submenus
 
 The built-in settings UI supports:
 
 - project/global scope toggle
+- source badges for project, global, and default values
+- Inherit/Reset actions that delete scoped config keys
 - grouped extension sections
 - searchable setting lists
 
@@ -83,24 +86,22 @@ The built-in settings UI supports:
 
 ```ts
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { loadSupiConfig, registerConfigSettings, wrapExtensionContext } from "@mrclrchtr/supi-core/api";
+import { loadSupiConfig, registerDeclarativeSettings, wrapExtensionContext } from "@mrclrchtr/supi-core/api";
 
 export default function myExtension(pi: ExtensionAPI) {
   const defaults = { enabled: true };
   const config = loadSupiConfig("my-extension", process.cwd(), defaults);
 
-  registerConfigSettings(pi, {
+  registerDeclarativeSettings(pi, {
     id: "my-extension",
     label: "My Extension",
     section: "my-extension",
     defaults,
-    buildItems: (settings) => [
+    fields: [
       {
-        id: "enabled",
+        kind: "boolean" as const,
+        key: "enabled",
         label: "Enabled",
-        currentValue: settings.enabled ? "on" : "off",
-        values: ["on", "off"],
-        configType: "boolean" as const,
       },
     ],
   });

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "SuPi core — shared infrastructure for SuPi extensions (XML context tags, config system)",
   "license": "MIT",
   "repository": {

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/config.ts

@@ -1,12 +1,11 @@
-// supi-core config domain — config loading and config-settings helpers.
+// supi-core config domain — config loading.
 export type { SupiConfigLocation, SupiConfigOptions } from "./config/config.ts";
 export {
   loadSectionConfig,
   loadSupiConfig,
   loadSupiConfigForScope,
+  loadSupiConfigSectionForScope,
   readJsonFile,
   removeSupiConfigKey,
   writeSupiConfig,
 } from "./config/config.ts";
-export type { ConfigSettingsHelpers, ConfigSettingsOptions } from "./config/config-settings.ts";
-export { registerConfigSettings } from "./config/config-settings.ts";

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/debug-registry.ts

@@ -6,8 +6,6 @@
 
 export type DebugLevel = "debug" | "info" | "warning" | "error";
 export type DebugAgentAccess = "off" | "sanitized" | "raw";
-export type DebugNotifyLevel = "off" | "warning" | "error";
-
 export interface DebugRegistryConfig {
   /** Whether producers should retain debug events. */
   enabled: boolean;
@@ -15,15 +13,12 @@ export interface DebugRegistryConfig {
   agentAccess: DebugAgentAccess;
   /** Maximum number of session-local events to keep in memory. */
   maxEvents: number;
-  /** Minimum level that should notify the user; interpreted by UI extensions. */
-  notifyLevel: DebugNotifyLevel;
 }
 
 export const DEBUG_REGISTRY_DEFAULTS: DebugRegistryConfig = {
   enabled: false,
   agentAccess: "sanitized",
   maxEvents: 100,
-  notifyLevel: "off",
 };
 
 export interface DebugEventInput {

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/settings/scoped-settings-list.ts

@@ -0,0 +1,372 @@
+// Scoped settings list component for SuPi settings overlay.
+//
+// Replaces pi-tui's generic SettingsList with a source-aware list that
+// renders source badges, dispatches Enter / Space / action-menu semantics,
+// and delegates custom-field submenus.
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Input, Key, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import type { ThemeAccessor } from "./settings-action-menu.ts";
+import {
+  buildActionMenu,
+  createActionMenuComponent,
+  getConcreteChoices,
+} from "./settings-action-menu.ts";
+import type { SettingsScope, SettingsSection } from "./settings-registry.ts";
+import type { ScopedFieldValue, SettingsFieldAction } from "./settings-schema.ts";
+import { createInputSubmenu, createModelPickerSubmenu } from "./settings-submenus.ts";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Scoped settings list
+// ═══════════════════════════════════════════════════════════════════════════
+
+interface ScopedRow {
+  flatId: string;
+  sectionLabel: string;
+  field: ScopedFieldValue;
+}
+
+interface SubmenuState {
+  component: {
+    render: (w: number) => string[];
+    invalidate?: () => void;
+    handleInput?: (data: string) => void;
+  };
+  onDone: () => void;
+}
+
+export class ScopedSettingsList {
+  private sections: SettingsSection[];
+  private scope: SettingsScope;
+  private cwd: string;
+  private ctx: ExtensionContext | undefined;
+  private theme: ThemeAccessor;
+  private tui: { requestRender: () => void };
+  private onCancel: () => void;
+  private onError?: (message: string) => void;
+  private rows: ScopedRow[] = [];
+  private selectedIndex = 0;
+  private submenu: SubmenuState | null = null;
+  private searchInput?: Input;
+  private searchQuery = "";
+  private cachedWidth?: number;
+  private cachedLines?: string[];
+
+  // biome-ignore lint/complexity/useMaxParams: component constructor needs all dependencies upfront for immutable wiring
+  constructor(
+    sections: SettingsSection[],
+    scope: SettingsScope,
+    cwd: string,
+    ctx: ExtensionContext | undefined,
+    theme: ThemeAccessor,
+    tui: { requestRender: () => void },
+    onCancel: () => void,
+    onError?: (message: string) => void,
+  ) {
+    this.sections = sections;
+    this.scope = scope;
+    this.cwd = cwd;
+    this.ctx = ctx;
+    this.theme = theme;
+    this.tui = tui;
+    this.onCancel = onCancel;
+    this.onError = onError;
+    this.rebuildRows();
+  }
+
+  reload(scope: SettingsScope, cwd: string, ctx?: ExtensionContext): void {
+    this.scope = scope;
+    this.cwd = cwd;
+    this.ctx = ctx;
+    this.rebuildRows();
+    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.rows.length - 1));
+    this.invalidate();
+  }
+
+  invalidate(): void {
+    this.cachedWidth = undefined;
+    this.cachedLines = undefined;
+  }
+
+  render(width: number): string[] {
+    if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+    if (this.submenu) {
+      this.cachedWidth = width;
+      this.cachedLines = this.submenu.component.render(width);
+      return this.cachedLines;
+    }
+    this.cachedWidth = width;
+    this.cachedLines = this.renderList(width);
+    return this.cachedLines;
+  }
+
+  private renderList(width: number): string[] {
+    const lines: string[] = [];
+    if (this.searchInput) {
+      lines.push(...this.searchInput.render(width));
+      lines.push("");
+    }
+    const displayRows = this.filteredRows();
+    if (displayRows.length === 0) {
+      lines.push(
+        this.theme.fg(
+          "dim",
+          this.searchQuery ? "  No matching settings" : "  No settings available",
+        ),
+      );
+      lines.push("");
+      lines.push(this.renderHint(width));
+      return lines;
+    }
+    const maxVisible = Math.min(displayRows.length + 2, 20);
+    const start = Math.max(
+      0,
+      Math.min(this.selectedIndex - Math.floor(maxVisible / 2), displayRows.length - maxVisible),
+    );
+    const end = Math.min(start + maxVisible, displayRows.length);
+    for (let i = start; i < end; i++) {
+      const row = displayRows[i];
+      if (!row) continue;
+      const isSelected = i === this.selectedIndex;
+      const prefix = isSelected ? "› " : "  ";
+      const section = this.theme.fg("dim", `${row.sectionLabel}: `);
+      const label = isSelected
+        ? this.theme.fg("accent", row.field.field.label)
+        : this.theme.fg("text", row.field.field.label);
+      lines.push(truncateToWidth(`${prefix}${section}${label}  ${row.field.displayValue}`, width));
+    }
+    if (start > 0 || end < displayRows.length) {
+      lines.push(this.theme.fg("dim", `  (${this.selectedIndex + 1}/${displayRows.length})`));
+    }
+    lines.push("");
+    lines.push(this.renderHint(width));
+    return lines;
+  }
+
+  private renderHint(_width: number): string {
+    const hints = [];
+    if (this.searchInput) hints.push("Type to search");
+    hints.push("Enter actions", "Space cycle", "Esc close");
+    return this.theme.fg("dim", hints.join(" · "));
+  }
+
+  handleInput(data: string): void {
+    if (this.submenu) {
+      this.submenu.component.handleInput?.(data);
+      this.invalidate();
+      this.tui.requestRender();
+      return;
+    }
+    if (matchesKey(data, Key.escape)) {
+      this.onCancel();
+      return;
+    }
+    if (matchesKey(data, Key.up)) {
+      this.moveSelection(-1);
+      return;
+    }
+    if (matchesKey(data, Key.down)) {
+      this.moveSelection(1);
+      return;
+    }
+    if (matchesKey(data, Key.enter)) {
+      this.activateSelected();
+      return;
+    }
+    if (data === " ") {
+      this.cycleSelected();
+      return;
+    }
+    if (this.searchInput) {
+      const sanitized = data.replace(/ /g, "");
+      if (sanitized) {
+        this.searchInput.handleInput(sanitized);
+        this.searchQuery = this.searchInput.getValue();
+        this.selectedIndex = 0;
+        this.invalidate();
+        this.tui.requestRender();
+      }
+    }
+  }
+
+  private moveSelection(delta: number): void {
+    const rows = this.filteredRows();
+    if (rows.length === 0) return;
+    this.selectedIndex =
+      delta < 0
+        ? this.selectedIndex <= 0
+          ? rows.length - 1
+          : this.selectedIndex - 1
+        : this.selectedIndex >= rows.length - 1
+          ? 0
+          : this.selectedIndex + 1;
+    this.invalidate();
+    this.tui.requestRender();
+  }
+
+  enableSearch(): void {
+    if (!this.searchInput) this.searchInput = new Input();
+  }
+
+  private rebuildRows(): void {
+    const rows: ScopedRow[] = [];
+    for (const section of this.sections) {
+      for (const value of section.loadValues(this.scope, this.cwd, this.ctx)) {
+        rows.push({
+          flatId: `${section.id}.${value.field.key}`,
+          sectionLabel: section.label,
+          field: value,
+        });
+      }
+    }
+    this.rows = rows;
+  }
+
+  private filteredRows(): ScopedRow[] {
+    if (!this.searchQuery) return this.rows;
+    const q = this.searchQuery.toLowerCase();
+    return this.rows.filter(
+      (r) =>
+        r.field.field.label.toLowerCase().includes(q) ||
+        r.field.field.key.toLowerCase().includes(q) ||
+        r.field.displayValue.toLowerCase().includes(q),
+    );
+  }
+
+  private activateSelected(): void {
+    const rows = this.filteredRows();
+    const row = rows[this.selectedIndex];
+    if (!row) return;
+
+    const menu = buildActionMenu(row.field, this.scope);
+    if (menu.length === 0) return;
+    this.submenu = {
+      component: createActionMenuComponent(menu, this.doneAction(row), this.theme),
+      onDone: () => {
+        this.submenu = null;
+        this.invalidate();
+        this.tui.requestRender();
+      },
+    };
+    this.invalidate();
+    this.tui.requestRender();
+  }
+
+  private doneAction(row: ScopedRow): (action?: string) => void {
+    return (action) => {
+      this.submenu = null;
+      if (!action) {
+        this.invalidate();
+        this.tui.requestRender();
+        return;
+      }
+      if (action === "inherit") {
+        this.dispatchAction(row.flatId, { kind: "inherit" });
+      } else if (action === "resetToDefault") {
+        this.dispatchAction(row.flatId, { kind: "resetToDefault" });
+      } else if (action === "edit") {
+        this.openFreeInputSubmenu(row);
+      } else if (action.startsWith("set:")) {
+        this.dispatchAction(row.flatId, { kind: "set", value: action.slice(4) });
+      }
+      this.invalidate();
+      this.tui.requestRender();
+    };
+  }
+
+  private cycleSelected(): void {
+    const rows = this.filteredRows();
+    const row = rows[this.selectedIndex];
+    if (!row) return;
+    const choices = getConcreteChoices(row.field.field);
+    if (choices.length === 0) return;
+    const idx = choices.indexOf(row.field.editValue);
+    const next = choices[idx < 0 ? 0 : (idx + 1) % choices.length] ?? choices[0];
+    if (next) this.dispatchAction(row.flatId, { kind: "set", value: next });
+  }
+
+  private openFreeInputSubmenu(row: ScopedRow): void {
+    const cleanValue = row.field.editValue;
+    if (row.field.field.kind === "custom" && row.field.field.submenu) {
+      const comp = row.field.field.submenu(
+        cleanValue,
+        (selectedValue) => {
+          this.submenu = null;
+          if (selectedValue !== undefined) {
+            this.dispatchAction(row.flatId, { kind: "set", value: selectedValue });
+          } else {
+            this.reload(this.scope, this.cwd, this.ctx);
+          }
+          this.invalidate();
+          this.tui.requestRender();
+        },
+        this.scope,
+        this.cwd,
+        this.ctx,
+      );
+      this.submenu = {
+        component: comp,
+        onDone: () => {
+          this.submenu = null;
+          this.reload(this.scope, this.cwd, this.ctx);
+          this.invalidate();
+          this.tui.requestRender();
+        },
+      };
+    } else if (row.field.field.kind === "modelPicker") {
+      this.submenu = {
+        component: createModelPickerSubmenu(
+          cleanValue,
+          (v) => {
+            this.submenu = null;
+            if (v !== undefined) this.dispatchAction(row.flatId, { kind: "set", value: v });
+            this.invalidate();
+            this.tui.requestRender();
+          },
+          this.ctx,
+        ),
+        onDone: () => {
+          this.submenu = null;
+          this.invalidate();
+          this.tui.requestRender();
+        },
+      };
+    } else {
+      const label =
+        row.field.field.kind === "stringList"
+          ? "Enter values (comma-separated):"
+          : `Enter ${row.field.field.label.toLowerCase()}:`;
+      this.submenu = {
+        component: createInputSubmenu(cleanValue, label, (v) => {
+          this.submenu = null;
+          if (v !== undefined) this.dispatchAction(row.flatId, { kind: "set", value: v });
+          this.invalidate();
+          this.tui.requestRender();
+        }),
+        onDone: () => {
+          this.submenu = null;
+          this.invalidate();
+          this.tui.requestRender();
+        },
+      };
+    }
+    this.invalidate();
+    this.tui.requestRender();
+  }
+
+  private dispatchAction(flatId: string, action: SettingsFieldAction): void {
+    const dotIndex = flatId.indexOf(".");
+    if (dotIndex === -1) return;
+    const sectionId = flatId.slice(0, dotIndex);
+    const fieldKey = flatId.slice(dotIndex + 1);
+    const section = this.sections.find((s) => s.id === sectionId);
+    if (!section) return;
+    try {
+      section.handleAction(this.scope, this.cwd, fieldKey, action, this.ctx);
+    } catch (err) {
+      this.onError?.(err instanceof Error ? err.message : String(err));
+    }
+    this.reload(this.scope, this.cwd, this.ctx);
+    this.tui.requestRender();
+  }
+}

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/settings/settings-action-menu.ts

@@ -0,0 +1,101 @@
+// Action menu component for SuPi settings rows.
+//
+// Builds context-sensitive action menus for scoped settings rows: concrete
+// value choices, Inherit from global, Use default, and Reset to default.
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Container, type SelectItem, SelectList, Text } from "@earendil-works/pi-tui";
+import type { SettingsScope } from "./settings-registry.ts";
+import type { ScopedFieldValue, SettingsField } from "./settings-schema.ts";
+
+/** Theme accessor type matching the TUI custom() theme parameter. */
+export type ThemeAccessor = Parameters<Parameters<ExtensionContext["ui"]["custom"]>[0]>[1];
+
+/** One selectable action in the row action menu. */
+export interface ActionMenuItem {
+  value: string;
+  label: string;
+}
+
+/**
+ * Build the action menu for a settings row given its field state and scope.
+ *
+ * Menu items include concrete value choices (for cycling fields), edit actions
+ * (for free-input fields), and scope-aware Inherit/Reset-to-default actions.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: 5-way branch on field kind + 3-way on scope/source is the natural discriminator for per-kind row actions
+export function buildActionMenu(field: ScopedFieldValue, scope: SettingsScope): ActionMenuItem[] {
+  const menu: ActionMenuItem[] = [];
+
+  if (field.field.kind === "custom") {
+    if (field.field.submenu) menu.push({ value: "edit", label: "Edit…" });
+  } else {
+    const choices = getConcreteChoices(field.field);
+    if (choices.length > 0) {
+      for (const choice of choices) menu.push({ value: `set:${choice}`, label: choice });
+    } else if (field.field.kind === "number") menu.push({ value: "edit", label: "Edit value…" });
+    else if (field.field.kind === "stringList") menu.push({ value: "edit", label: "Edit values…" });
+    else if (field.field.kind === "modelPicker")
+      menu.push({ value: "edit", label: "Choose model…" });
+  }
+
+  if (scope === "project") {
+    if (field.source === "project") {
+      const label = field.inheritanceSource === "global" ? "Inherit from global" : "Use default";
+      menu.push({ value: "inherit", label });
+    }
+  } else if (field.source === "global") {
+    menu.push({ value: "resetToDefault", label: "Reset to default" });
+  }
+
+  return menu;
+}
+
+/**
+ * Return the concrete string choices for a field that supports Space cycling.
+ * Returns an empty array for fields that use free-text input or submenus.
+ */
+export function getConcreteChoices(field: SettingsField): string[] {
+  switch (field.kind) {
+    case "boolean":
+      return ["on", "off"];
+    case "enum":
+      return field.values;
+    case "number":
+      return field.values ?? [];
+    default:
+      return [];
+  }
+}
+
+/**
+ * Create a pi-tui SelectList-backed action menu component.
+ */
+export function createActionMenuComponent(
+  menu: ActionMenuItem[],
+  done: (action?: string) => void,
+  theme: ThemeAccessor,
+) {
+  const items: SelectItem[] = menu.map((m) => ({ value: m.value, label: m.label }));
+  const container = new Container();
+  container.addChild(new Text(theme.fg("accent", "  Actions"), 1, 0));
+  const selectList = new SelectList(items, Math.min(items.length + 2, 15), {
+    selectedPrefix: (t) => theme.fg("accent", t),
+    selectedText: (t) => theme.fg("accent", t),
+    description: (t) => theme.fg("muted", t),
+    scrollInfo: (t) => theme.fg("dim", t),
+    noMatch: (t) => theme.fg("warning", t),
+  });
+  selectList.onSelect = (item) => done(item.value);
+  selectList.onCancel = () => done();
+  container.addChild(selectList);
+  container.addChild(new Text(theme.fg("dim", "  ↑↓ navigate • enter select • esc cancel"), 1, 0));
+  return {
+    render: (width: number) => container.render(width),
+    invalidate: () => container.invalidate(),
+    handleInput: (data: string) => {
+      selectList.handleInput(data);
+      return true;
+    },
+  };
+}

package/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/settings/settings-registry.ts

@@ -1,11 +1,11 @@
 // Event-backed settings contribution types for SuPi extensions.
 //
-// Extensions contribute config-backed settings sections through PI's shared
-// event bus. The public helper is registerConfigSettings(pi, ...); this module
+// Extensions contribute declarative settings sections through PI's shared
+// event bus. The public helper is registerDeclarativeSettings(pi, ...); this module
 // owns the internal collector protocol used by /supi-settings.
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { SettingItem } from "@earendil-works/pi-tui";
+import type { ScopedFieldValue, SettingsFieldAction } from "./settings-schema.ts";
 
 export const SUPI_SETTINGS_COLLECT_EVENT = "supi:settings:collect";
 
@@ -16,10 +16,16 @@ export interface SettingsSection {
   id: string;
   /** Human-readable label shown in the UI. */
   label: string;
-  /** Load current SettingItem[] for the given scope. */
-  loadValues: (scope: SettingsScope, cwd: string, ctx?: ExtensionContext) => SettingItem[];
-  /** Persist a UI value back to SuPi config. */
-  persistChange: (scope: SettingsScope, cwd: string, settingId: string, value: string) => void;
+  /** Load current ScopedFieldValue[] for the given scope. */
+  loadValues: (scope: SettingsScope, cwd: string, ctx?: ExtensionContext) => ScopedFieldValue[];
+  /** Handle a user action on a field in the selected scope. */
+  handleAction: (
+    scope: SettingsScope,
+    cwd: string,
+    fieldKey: string,
+    action: SettingsFieldAction,
+    ctx?: ExtensionContext,
+  ) => void;
 }
 
 export interface SettingsContributionCollector {