@mrclrchtr/supi-extras 7.2.1 → 7.3.1

package/src/session-capabilities-tools.ts

@@ -0,0 +1,103 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { SessionCapabilityState } from "@mrclrchtr/supi-core/session";
+import { isExtensionTool } from "./session-capabilities-state.ts";
+import type { CapabilityToolItem } from "./session-capabilities-ui.ts";
+
+/** Enforce the current session tool choices without changing other active tools. */
+export function applyToolDenylist(
+  pi: ExtensionAPI,
+  state: SessionCapabilityState,
+  restoreNames: readonly string[],
+  restorableNames: ReadonlySet<string>,
+): void {
+  const available = new Set(
+    pi
+      .getAllTools()
+      .filter(isExtensionTool)
+      .map((tool) => tool.name),
+  );
+  const eligible = new Set(state.eligibleToolNames);
+  const initiallyInactive = new Set(state.initiallyInactiveToolNames);
+  const denied = new Set(
+    state.toolDenylist.filter(
+      (name) => available.has(name) && eligible.has(name) && !initiallyInactive.has(name),
+    ),
+  );
+  const active = pi.getActiveTools();
+  const activeSet = new Set(active);
+  const next = active.filter((name) => !denied.has(name));
+  const nextSet = new Set(next);
+
+  for (const name of restoreNames) {
+    if (
+      available.has(name) &&
+      eligible.has(name) &&
+      restorableNames.has(name) &&
+      !initiallyInactive.has(name) &&
+      !denied.has(name) &&
+      !activeSet.has(name) &&
+      !nextSet.has(name)
+    ) {
+      next.push(name);
+      nextSet.add(name);
+    }
+  }
+
+  if (next.length !== active.length || next.some((name, index) => name !== active[index])) {
+    pi.setActiveTools(next);
+  }
+}
+
+/** Add a late tool to the restore boundary only when PI has activated it. */
+export function observeNewTools(
+  pi: ExtensionAPI,
+  state: SessionCapabilityState,
+  knownToolNames: Set<string>,
+  restorableToolNames: Set<string>,
+): void {
+  const activeNames = new Set(pi.getActiveTools());
+  const initiallyInactive = new Set(state.initiallyInactiveToolNames);
+  for (const tool of pi.getAllTools().filter(isExtensionTool)) {
+    if (knownToolNames.has(tool.name)) continue;
+    knownToolNames.add(tool.name);
+    if (activeNames.has(tool.name) && !initiallyInactive.has(tool.name)) {
+      restorableToolNames.add(tool.name);
+    }
+  }
+}
+
+/** Reconcile known tools while retaining restrictions for tools not registered yet. */
+export function reconcileToolInventory(
+  pi: ExtensionAPI,
+  state: SessionCapabilityState,
+): { tools: CapabilityToolItem[]; changed: boolean } {
+  const tools = pi.getAllTools().filter(isExtensionTool);
+  const activeNames = new Set(pi.getActiveTools());
+  const previous = JSON.stringify(state);
+  const initiallyInactive = new Set(state.initiallyInactiveToolNames);
+  const eligible = new Set(state.eligibleToolNames.filter((name) => !initiallyInactive.has(name)));
+
+  for (const tool of tools) {
+    if (activeNames.has(tool.name) && !initiallyInactive.has(tool.name)) eligible.add(tool.name);
+  }
+
+  state.initiallyInactiveToolNames = Array.from(initiallyInactive);
+  state.eligibleToolNames = Array.from(eligible);
+  state.toolDenylist = state.toolDenylist.filter((name) => eligible.has(name));
+  state.toolEnabledNames = (state.toolEnabledNames ?? []).filter(
+    (name) => eligible.has(name) && !state.toolDenylist.includes(name),
+  );
+
+  const denied = new Set(state.toolDenylist);
+  const visibleTools = tools.filter(
+    (tool) => eligible.has(tool.name) && (activeNames.has(tool.name) || denied.has(tool.name)),
+  );
+  return {
+    tools: visibleTools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      source: tool.sourceInfo.source,
+    })),
+    changed: previous !== JSON.stringify(state),
+  };
+}

package/src/session-capabilities-ui-rows.ts

@@ -0,0 +1,192 @@
+import type { SelectItem } from "@earendil-works/pi-tui";
+import type { SessionCapabilitySkill, SessionCapabilityState } from "@mrclrchtr/supi-core/session";
+
+/** A section shown by the session capability selector. */
+export type CapabilitySection = "tools" | "skills";
+
+/** A tool row that the session selector can display. */
+export interface CapabilityToolItem {
+  name: string;
+  description: string;
+  source: string;
+}
+
+/** One action, group, toggle, or information row in the selector. */
+export interface CapabilityRow {
+  id: string;
+  label: string;
+  currentValue: string;
+  description?: string;
+  indent: number;
+  searchText: string;
+  parentId?: string;
+  toggleValues?: readonly [string, string];
+  actions?: SelectItem[];
+}
+
+function actionRow(options: {
+  id: string;
+  label: string;
+  value: string;
+  description: string;
+  action: SelectItem;
+}): CapabilityRow {
+  return {
+    id: options.id,
+    label: options.label,
+    currentValue: options.value,
+    description: options.description,
+    indent: 2,
+    searchText: options.label,
+    actions: [options.action],
+  };
+}
+
+function toolRows(tools: CapabilityToolItem[], state: SessionCapabilityState): CapabilityRow[] {
+  const denied = new Set(state.toolDenylist);
+  const grouped = new Map<string, CapabilityToolItem[]>();
+  for (const tool of tools) {
+    const group = grouped.get(tool.source) ?? [];
+    group.push(tool);
+    grouped.set(tool.source, group);
+  }
+
+  const rows: CapabilityRow[] = [
+    actionRow({
+      id: "disable-all-tools",
+      label: "Disable All Tools",
+      value: "Apply",
+      description: "Disable all current eligible extension tools for this session.",
+      action: { value: "Apply", label: "Disable all tools" },
+    }),
+    actionRow({
+      id: "reset-tools",
+      label: "Reset Tools",
+      value: "Reset",
+      description: "Restore tools that this selector disabled.",
+      action: { value: "Reset", label: "Restore tools" },
+    }),
+    actionRow({
+      id: "reset-all",
+      label: "Reset All",
+      value: "Reset",
+      description: "Restore all session capability overrides.",
+      action: { value: "Reset", label: "Restore all session overrides" },
+    }),
+  ];
+
+  for (const [source, sourceTools] of Array.from(grouped.entries()).sort(([a], [b]) =>
+    a.localeCompare(b),
+  )) {
+    const sortedTools = [...sourceTools].sort((a, b) => a.name.localeCompare(b.name));
+    const disabledCount = sortedTools.filter((tool) => denied.has(tool.name)).length;
+    const groupValue =
+      disabledCount === 0 ? "Enabled" : disabledCount === sortedTools.length ? "Disabled" : "Mixed";
+    const groupId = `package:${source}`;
+    rows.push({
+      id: groupId,
+      label: source,
+      currentValue: groupValue,
+      description: "Toggle current eligible tools from this PI source.",
+      indent: 2,
+      searchText: source,
+      actions: [
+        { value: "disable", label: "Disable package tools" },
+        { value: "enable", label: "Enable package tools" },
+      ],
+    });
+    for (const tool of sortedTools) {
+      rows.push({
+        id: `tool:${tool.name}`,
+        label: tool.name,
+        currentValue: denied.has(tool.name) ? "Disabled" : "Enabled",
+        description: tool.description,
+        indent: 4,
+        searchText: `${tool.name} ${source}`,
+        parentId: groupId,
+        toggleValues: ["Enabled", "Disabled"],
+        actions: [
+          { value: "Enabled", label: "Enable tool" },
+          { value: "Disabled", label: "Disable tool" },
+        ],
+      });
+    }
+  }
+  return rows;
+}
+
+function skillRows(
+  skills: SessionCapabilitySkill[] | undefined,
+  state: SessionCapabilityState,
+): CapabilityRow[] {
+  const hidden = new Set(state.hiddenSkillNames);
+  const rows: CapabilityRow[] = [
+    actionRow({
+      id: "hide-all-skills",
+      label: "Hide All Skills",
+      value: "Apply",
+      description: "Hide all current model-visible skills for this session.",
+      action: { value: "Apply", label: "Hide all skills" },
+    }),
+    actionRow({
+      id: "reset-skills",
+      label: "Reset Skills",
+      value: "Reset",
+      description: "Show all eligible skills in the model catalog.",
+      action: { value: "Reset", label: "Show all skills" },
+    }),
+    actionRow({
+      id: "reset-all",
+      label: "Reset All",
+      value: "Reset",
+      description: "Restore all session capability overrides.",
+      action: { value: "Reset", label: "Restore all session overrides" },
+    }),
+  ];
+
+  if (!skills) {
+    rows.push({
+      id: "skills-unavailable",
+      label: "Skills are not available",
+      currentValue: "",
+      description: "Load supi-skills to manage skills here.",
+      indent: 2,
+      searchText: "Skills are not available",
+    });
+  } else if (skills.length === 0) {
+    rows.push({
+      id: "no-skills",
+      label: "No eligible skills",
+      currentValue: "",
+      indent: 2,
+      searchText: "No eligible skills",
+    });
+  } else {
+    for (const skill of skills) {
+      rows.push({
+        id: `skill:${skill.name}`,
+        label: skill.name,
+        currentValue: hidden.has(skill.name) ? "Hidden" : "Visible",
+        description: skill.description,
+        indent: 2,
+        searchText: skill.name,
+        toggleValues: ["Visible", "Hidden"],
+        actions: [
+          { value: "Visible", label: "Show skill" },
+          { value: "Hidden", label: "Hide skill" },
+        ],
+      });
+    }
+  }
+  return rows;
+}
+
+/** Build the rows for one session capability section. */
+export function buildCapabilityRows(
+  section: CapabilitySection,
+  tools: CapabilityToolItem[],
+  skills: SessionCapabilitySkill[] | undefined,
+  state: SessionCapabilityState,
+): CapabilityRow[] {
+  return section === "tools" ? toolRows(tools, state) : skillRows(skills, state);
+}

package/src/session-capabilities-ui.ts

@@ -0,0 +1,356 @@
+import { DynamicBorder, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import {
+  fuzzyFilter,
+  Input,
+  Key,
+  matchesKey,
+  type TuiMouseEvent,
+  type TuiMouseEventResult,
+  truncateToWidth,
+  visibleWidth,
+} from "@earendil-works/pi-tui";
+import type { SessionCapabilitySkill, SessionCapabilityState } from "@mrclrchtr/supi-core/session";
+import {
+  createSelectListMenu,
+  formatTuiTitleLine,
+  renderDescriptionViewport,
+  renderSelectableRow,
+  renderTuiHintLine,
+} from "@mrclrchtr/supi-core/tui";
+import {
+  buildCapabilityRows,
+  type CapabilityRow,
+  type CapabilitySection,
+  type CapabilityToolItem,
+} from "./session-capabilities-ui-rows.ts";
+
+export type { CapabilityToolItem } from "./session-capabilities-ui-rows.ts";
+
+const MAX_VISIBLE_ROWS = 10;
+const HEADER_HEIGHT = 2;
+
+interface SelectorComponent {
+  render(width: number): string[];
+  invalidate(): void;
+  handleInput(data: string): void;
+  handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined;
+}
+
+interface CapabilitySelectorOptions {
+  done: (result: undefined) => void;
+  onChange: (id: string, value: string) => void;
+  skills: SessionCapabilitySkill[] | undefined;
+  state: SessionCapabilityState;
+  theme: ExtensionUIContext["theme"];
+  tools: CapabilityToolItem[];
+  tui: { requestRender(): void };
+}
+
+type RowLayout = { maxLabelWidth: number; maxIndent: number; width: number };
+
+class CapabilityList implements SelectorComponent {
+  private rows: CapabilityRow[];
+  private selectedIndex = 0;
+  private menu: SelectorComponent | null = null;
+  private mousePressedIndex: number | undefined;
+  private readonly searchInput = new Input();
+  private searchQuery = "";
+  private cachedWidth?: number;
+  private cachedLines?: string[];
+
+  constructor(
+    private readonly section: CapabilitySection,
+    private readonly options: CapabilitySelectorOptions,
+  ) {
+    this.rows = this.buildRows();
+  }
+
+  hasOpenMenu(): boolean {
+    return this.menu !== null;
+  }
+
+  invalidate(): void {
+    this.cachedWidth = undefined;
+    this.cachedLines = undefined;
+    this.searchInput.invalidate();
+    this.menu?.invalidate();
+  }
+
+  render(width: number): string[] {
+    if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+    this.cachedWidth = width;
+    this.cachedLines = this.menu ? this.menu.render(width) : this.renderRows(width);
+    return this.cachedLines;
+  }
+
+  handleInput(data: string): void {
+    if (this.menu) {
+      this.menu.handleInput(data);
+      this.invalidate();
+      this.options.tui.requestRender();
+      return;
+    }
+    if (matchesKey(data, Key.escape)) {
+      this.options.done(undefined);
+    } else if (matchesKey(data, Key.up)) {
+      this.moveSelection(-1);
+    } else if (matchesKey(data, Key.down)) {
+      this.moveSelection(1);
+    } else if (matchesKey(data, Key.enter)) {
+      this.activateSelected();
+    } else if (data === " ") {
+      this.toggleSelected();
+    } else {
+      this.searchInput.handleInput(data);
+      this.searchQuery = this.searchInput.getValue();
+      this.selectedIndex = 0;
+      this.invalidate();
+      this.options.tui.requestRender();
+    }
+  }
+
+  handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+    if (this.menu) return this.menu.handleMouse(event);
+    if (event.type === "wheel" && event.wheelDelta) return this.handleWheel(event.wheelDelta);
+    if (event.y === 0) return this.handleSearchMouse(event);
+    if (
+      event.y === 1 ||
+      event.button !== "left" ||
+      (event.type !== "press" && event.type !== "click")
+    ) {
+      return undefined;
+    }
+    return this.handleRowMouse(event);
+  }
+
+  private buildRows(): CapabilityRow[] {
+    return buildCapabilityRows(
+      this.section,
+      this.options.tools,
+      this.options.skills,
+      this.options.state,
+    );
+  }
+
+  private filteredRows(): CapabilityRow[] {
+    if (!this.searchQuery) return this.rows;
+    const matches = fuzzyFilter(this.rows, this.searchQuery, (row) => row.searchText);
+    const matchingIds = new Set(matches.map((row) => row.id));
+    const parentIds = new Set(matches.flatMap((row) => (row.parentId ? [row.parentId] : [])));
+    return this.rows.filter((row) => matchingIds.has(row.id) || parentIds.has(row.id));
+  }
+
+  private visibleRange(length: number): { start: number; end: number } {
+    const maxVisible = Math.min(length, MAX_VISIBLE_ROWS);
+    const start = Math.max(
+      0,
+      Math.min(this.selectedIndex - Math.floor(maxVisible / 2), length - maxVisible),
+    );
+    return { start, end: Math.min(start + maxVisible, length) };
+  }
+
+  private renderRows(width: number): string[] {
+    const lines = [...this.searchInput.render(width), ""];
+    const rows = this.filteredRows();
+    if (rows.length === 0) return this.renderEmptyRows(lines, width);
+
+    const { start, end } = this.visibleRange(rows.length);
+    const maxLabelWidth = Math.min(30, Math.max(...rows.map((row) => visibleWidth(row.label))));
+    const maxIndent = Math.max(...rows.map((row) => row.indent));
+    lines.push(
+      ...this.renderVisibleRows(rows, { start, end }, { maxLabelWidth, maxIndent, width }),
+    );
+    if (start > 0 || end < rows.length) {
+      lines.push(this.options.theme.fg("dim", `  (${this.selectedIndex + 1}/${rows.length})`));
+    }
+    if (rows.some((row) => row.description)) {
+      lines.push("");
+      const description = renderDescriptionViewport(rows[this.selectedIndex]?.description, width);
+      lines.push(...description.map((line) => (line ? this.options.theme.fg("dim", line) : "")));
+    }
+    lines.push("", this.renderHint(width));
+    return lines;
+  }
+
+  private renderEmptyRows(lines: string[], width: number): string[] {
+    const text = this.searchQuery ? "  No matching capabilities" : "  No capabilities available";
+    lines.push(this.options.theme.fg("dim", text), "", this.renderHint(width));
+    return lines;
+  }
+
+  private renderVisibleRows(
+    rows: CapabilityRow[],
+    range: { start: number; end: number },
+    layout: RowLayout,
+  ): string[] {
+    const lines: string[] = [];
+    for (let index = range.start; index < range.end; index++) {
+      const row = rows[index];
+      if (row) lines.push(this.renderRow(row, index, layout));
+    }
+    return lines;
+  }
+
+  private renderRow(row: CapabilityRow, index: number, layout: RowLayout): string {
+    return renderSelectableRow({
+      label: row.label,
+      value: row.currentValue,
+      indent: row.indent,
+      maxIndent: layout.maxIndent,
+      maxLabelWidth: layout.maxLabelWidth,
+      width: layout.width,
+      selected: index === this.selectedIndex,
+      theme: this.options.theme,
+    });
+  }
+
+  private renderHint(width: number): string {
+    return renderTuiHintLine(
+      ["Type to search", "Enter for actions", "Space to toggle", "Tab to switch", "Esc to close"],
+      this.options.theme,
+      width,
+    );
+  }
+
+  private handleWheel(wheelDelta: number): TuiMouseEventResult {
+    const rows = this.filteredRows();
+    const previousIndex = this.selectedIndex;
+    this.selectedIndex = Math.max(
+      0,
+      Math.min(rows.length - 1, this.selectedIndex + (wheelDelta < 0 ? -1 : 1)),
+    );
+    const changed = previousIndex !== this.selectedIndex;
+    if (changed) this.invalidate();
+    return { handled: true, render: changed };
+  }
+
+  private handleSearchMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+    const result = this.searchInput.handleMouse(event);
+    return result ? { ...result, focus: true } : undefined;
+  }
+
+  private handleRowMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+    const rows = this.filteredRows();
+    if (rows.length === 0) return undefined;
+    const { start, end } = this.visibleRange(rows.length);
+    const rowIndex = start + event.y - 2;
+    if (rowIndex < start || rowIndex >= end) return undefined;
+    if (event.type === "press") {
+      this.mousePressedIndex = rowIndex;
+      this.selectedIndex = rowIndex;
+      this.invalidate();
+      return { handled: true, focus: true };
+    }
+    this.selectedIndex = this.mousePressedIndex ?? rowIndex;
+    this.mousePressedIndex = undefined;
+    const row = rows[this.selectedIndex];
+    if (row?.toggleValues) this.toggleSelected();
+    else this.activateSelected();
+    return { handled: true };
+  }
+
+  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.options.tui.requestRender();
+  }
+
+  private toggleSelected(): void {
+    const row = this.filteredRows()[this.selectedIndex];
+    if (!row?.toggleValues) return;
+    const [enabledValue, disabledValue] = row.toggleValues;
+    this.options.onChange(row.id, row.currentValue === enabledValue ? disabledValue : enabledValue);
+    this.refreshRows(row.id);
+  }
+
+  private activateSelected(): void {
+    const row = this.filteredRows()[this.selectedIndex];
+    if (!row?.actions?.length) return;
+    this.menu = createSelectListMenu({
+      title: "Actions",
+      items: row.actions,
+      theme: this.options.theme,
+      onSelect: (item) => {
+        this.menu = null;
+        this.options.onChange(row.id, item.value);
+        this.refreshRows(row.id);
+      },
+      onCancel: () => {
+        this.menu = null;
+        this.invalidate();
+        this.options.tui.requestRender();
+      },
+    });
+    this.invalidate();
+    this.options.tui.requestRender();
+  }
+
+  private refreshRows(selectedId: string): void {
+    this.rows = this.buildRows();
+    const rows = this.filteredRows();
+    const selectedIndex = rows.findIndex((row) => row.id === selectedId);
+    this.selectedIndex =
+      selectedIndex >= 0 ? selectedIndex : Math.min(this.selectedIndex, rows.length - 1);
+    this.invalidate();
+    this.options.tui.requestRender();
+  }
+}
+
+/** Build the searchable selector for the current session. */
+export function createCapabilitySelector(options: CapabilitySelectorOptions): SelectorComponent {
+  const { theme, tui } = options;
+  let section: CapabilitySection = "tools";
+  let list = new CapabilityList(section, options);
+  const topBorder = new DynamicBorder((text: string) => theme.fg("borderMuted", text));
+  const bottomBorder = new DynamicBorder((text: string) => theme.fg("borderMuted", text));
+
+  const renderTitle = (width: number): string => {
+    const tabs =
+      section === "tools"
+        ? `${theme.fg("accent", theme.bold("[Tools]"))}  ${theme.fg("dim", "Skills")}`
+        : `${theme.fg("dim", "Tools")}  ${theme.fg("accent", theme.bold("[Skills]"))}`;
+    return truncateToWidth(formatTuiTitleLine("Session Capabilities", theme, tabs), width);
+  };
+
+  return {
+    render(width) {
+      return [
+        ...topBorder.render(width),
+        renderTitle(width),
+        ...list.render(width),
+        ...bottomBorder.render(width),
+      ];
+    },
+    invalidate() {
+      topBorder.invalidate();
+      bottomBorder.invalidate();
+      list.invalidate();
+    },
+    handleInput(data) {
+      if (matchesKey(data, Key.tab) && !list.hasOpenMenu()) {
+        section = section === "tools" ? "skills" : "tools";
+        list = new CapabilityList(section, options);
+        tui.requestRender();
+        return;
+      }
+      list.handleInput(data);
+    },
+    handleMouse(event) {
+      if (event.y < HEADER_HEIGHT) return undefined;
+      return list.handleMouse({
+        ...event,
+        y: event.y - HEADER_HEIGHT,
+        height: Math.max(0, event.height - HEADER_HEIGHT - 1),
+      });
+    },
+  };
+}