@mrclrchtr/supi-code-intelligence 1.7.0 → 1.9.0

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

@@ -0,0 +1,186 @@
+// Shared config system for SuPi extensions.
+//
+// Global config: ~/.pi/agent/supi/config.json
+// Project config: .pi/supi/config.json (relative to cwd)
+// Resolution: hardcoded defaults ← global ← project
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const GLOBAL_CONFIG_DIR = ".pi/agent/supi";
+const PROJECT_CONFIG_DIR = ".pi/supi";
+const CONFIG_FILE = "config.json";
+
+function getGlobalConfigPath(homeDir?: string): string {
+  return path.join(homeDir ?? os.homedir(), GLOBAL_CONFIG_DIR, CONFIG_FILE);
+}
+
+function getProjectConfigPath(cwd: string): string {
+  return path.join(cwd, PROJECT_CONFIG_DIR, CONFIG_FILE);
+}
+
+export function readJsonFile(filePath: string): Record<string, unknown> | null {
+  let content: string;
+  try {
+    content = fs.readFileSync(filePath, "utf-8");
+  } catch {
+    // ENOENT or permission error — silent, file may not exist
+    return null;
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    // biome-ignore lint/suspicious/noConsole: deliberate config parse warning
+    console.warn(`[supi-core] Failed to parse config file, ignoring: ${filePath}`);
+    return null;
+  }
+
+  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+    return parsed as Record<string, unknown>;
+  }
+
+  // biome-ignore lint/suspicious/noConsole: deliberate config parse warning
+  console.warn(`[supi-core] Config file root is not an object, ignoring: ${filePath}`);
+  return null;
+}
+
+function shallowMerge<T>(base: T, ...overrides: Array<Record<string, unknown> | null>): T {
+  let result = { ...base };
+  for (const override of overrides) {
+    if (!override) continue;
+    result = { ...result, ...override };
+  }
+  return result;
+}
+
+export interface SupiConfigOptions {
+  homeDir?: string;
+}
+
+/**
+ * Load and merge config for a given extension section.
+ *
+ * Resolution order: defaults ← global ← project
+ */
+export function loadSupiConfig<T>(
+  section: string,
+  cwd: string,
+  defaults: T,
+  options?: SupiConfigOptions,
+): T {
+  const globalConfig = readJsonFile(getGlobalConfigPath(options?.homeDir));
+  const projectConfig = readJsonFile(getProjectConfigPath(cwd));
+
+  const globalSection = extractSection(globalConfig, section);
+  const projectSection = extractSection(projectConfig, section);
+
+  return shallowMerge(defaults, globalSection, projectSection);
+}
+
+/**
+ * Load config for a single scope only.
+ *
+ * Resolution order: defaults ← selected scope
+ *
+ * This is useful for settings UIs that need to show the raw values stored in
+ * one scope, rather than the effective merged config.
+ */
+export function loadSupiConfigForScope<T>(
+  section: string,
+  cwd: string,
+  defaults: T,
+  options: { scope: "global" | "project" } & SupiConfigOptions,
+): T {
+  const config =
+    options.scope === "global"
+      ? readJsonFile(getGlobalConfigPath(options.homeDir))
+      : readJsonFile(getProjectConfigPath(cwd));
+
+  const scopedSection = extractSection(config, section);
+  return shallowMerge(defaults, scopedSection);
+}
+
+export interface SupiConfigLocation {
+  section: string;
+  scope: "global" | "project";
+  cwd: string;
+}
+
+/**
+ * Write config values for a given extension section.
+ */
+export function writeSupiConfig(
+  loc: SupiConfigLocation,
+  value: Record<string, unknown>,
+  options?: SupiConfigOptions,
+): void {
+  const configPath =
+    loc.scope === "global" ? getGlobalConfigPath(options?.homeDir) : getProjectConfigPath(loc.cwd);
+
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const existing = readJsonFile(configPath) ?? {};
+  existing[loc.section] = {
+    ...((existing[loc.section] as Record<string, unknown>) ?? {}),
+    ...value,
+  };
+
+  fs.writeFileSync(configPath, `${JSON.stringify(existing, null, 2)}\n`, "utf-8");
+}
+
+/**
+ * Remove a key from a config section.
+ * Used by `interval default` to remove the project override.
+ */
+export function removeSupiConfigKey(
+  loc: SupiConfigLocation,
+  key: string,
+  options?: SupiConfigOptions,
+): void {
+  const configPath =
+    loc.scope === "global" ? getGlobalConfigPath(options?.homeDir) : getProjectConfigPath(loc.cwd);
+
+  const existing = readJsonFile(configPath);
+  if (!existing) return;
+
+  const sectionData = existing[loc.section] as Record<string, unknown> | undefined;
+  if (!sectionData) return;
+
+  delete sectionData[key];
+
+  if (Object.keys(sectionData).length === 0) {
+    delete existing[loc.section];
+  }
+
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const content = Object.keys(existing).length > 0 ? `${JSON.stringify(existing, null, 2)}\n` : "";
+
+  if (content) {
+    // Directory guaranteed to exist since we just read from it
+    fs.writeFileSync(configPath, content, "utf-8");
+  } else {
+    try {
+      fs.unlinkSync(configPath);
+    } catch {
+      // File may not exist
+    }
+  }
+}
+
+function extractSection(
+  config: Record<string, unknown> | null,
+  section: string,
+): Record<string, unknown> | null {
+  if (!config) return null;
+  const data = config[section];
+  if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+    return data as Record<string, unknown>;
+  }
+  return null;
+}

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

@@ -0,0 +1,11 @@
+// supi-core config domain — config loading and config-settings helpers.
+export type { SupiConfigLocation, SupiConfigOptions } from "./config/config.ts";
+export {
+  loadSupiConfig,
+  loadSupiConfigForScope,
+  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-lsp/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/context/context-messages.ts

@@ -0,0 +1,119 @@
+// Shared context-message utilities for SuPi extensions.
+//
+// Provides a generic prune-and-reorder pattern for extensions that inject
+// managed context messages (via `before_agent_start` with a `customType` and
+// `contextToken`) and maintain them via the `context` event.
+
+/**
+ * Minimal message shape needed for context-message operations.
+ * Extensions cast their event.messages entries to this type.
+ */
+export type ContextMessageLike = {
+  role?: string;
+  customType?: string;
+  content?: unknown;
+  details?: unknown;
+};
+
+/**
+ * Extract the `contextToken` string from a message's `details` object.
+ * Returns `null` when the token is absent or not a string.
+ */
+export function getContextToken(details: unknown): string | null {
+  if (!details || typeof details !== "object") return null;
+  const token = (details as { contextToken?: unknown }).contextToken;
+  return typeof token === "string" ? token : null;
+}
+
+/**
+ * Find the index of the last message with `role: "user"`.
+ * Returns `-1` when no user message exists.
+ */
+export function findLastUserMessageIndex<T extends ContextMessageLike>(messages: T[]): number {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    if (messages[index]?.role === "user") return index;
+  }
+  return -1;
+}
+
+/**
+ * Filter stale context messages and reorder the active one before the last user message.
+ *
+ * - Removes all messages matching `customType` whose token differs from `activeToken`.
+ * - When `activeToken` is `null`, removes **all** messages of that `customType`.
+ * - If the active context message is after the last user message, moves it before.
+ *
+ * Returns the modified array, or the original reference when no changes were needed.
+ */
+export function pruneAndReorderContextMessages<T extends ContextMessageLike>(
+  messages: T[],
+  customType: string,
+  activeToken: string | null,
+): T[] {
+  // Remove stale messages of the target customType
+  const filtered = messages.filter((message) => {
+    if (message.customType !== customType) return true;
+    if (!activeToken) return false;
+    return getContextToken(message.details) === activeToken;
+  });
+
+  if (!activeToken) return filtered;
+
+  // Find the active context message
+  const contextIndex = filtered.findIndex(
+    (message) =>
+      message.customType === customType && getContextToken(message.details) === activeToken,
+  );
+  if (contextIndex === -1) return filtered;
+
+  // Find the last user message
+  const userIndex = findLastUserMessageIndex(filtered);
+  if (userIndex === -1 || contextIndex < userIndex) return filtered;
+
+  // Move context message before last user message
+  const next = [...filtered];
+  const [contextMessage] = next.splice(contextIndex, 1);
+  if (!contextMessage) return filtered;
+  next.splice(userIndex, 0, contextMessage);
+  return next;
+}
+
+/**
+ * Restore the raw prompt content on a context message that was swapped for display text.
+ *
+ * Extensions using `registerMessageRenderer` store their LLM-facing content in
+ * `details.promptContent` and put a human-readable summary in `content`. This function
+ * reverses the swap so the model sees the original prompt content.
+ *
+ * Returns the original array reference when no change is needed.
+ */
+export function restorePromptContent<T extends ContextMessageLike>(
+  messages: T[],
+  customType: string,
+  activeToken: string | null,
+): T[] {
+  if (!activeToken) return messages;
+
+  const index = messages.findIndex(
+    (message) =>
+      message.customType === customType && getContextToken(message.details) === activeToken,
+  );
+  if (index === -1) return messages;
+
+  const promptContent = getPromptContent(messages[index]?.details);
+  if (!promptContent || messages[index]?.content === promptContent) return messages;
+
+  const next = [...messages];
+  next[index] = { ...next[index], content: promptContent };
+  return next;
+}
+
+/**
+ * Extract the `promptContent` string from a message's `details` object.
+ * Returns `null` when absent or not a string.
+ */
+export function getPromptContent(details: unknown): string | null {
+  if (!details || typeof details !== "object") return null;
+  const promptContent = (details as { promptContent?: unknown }).promptContent;
+  return typeof promptContent === "string" ? promptContent : null;
+}

package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/context/context-provider-registry.ts

@@ -0,0 +1,36 @@
+// Context provider registry for SuPi extensions.
+//
+// Extensions declare context data providers via `registerContextProvider()` during their
+// factory function. The `/supi-context` command reads them via `getRegisteredContextProviders()`.
+
+import { createRegistry } from "../registry-utils.ts";
+
+export interface ContextProvider {
+  /** Unique identifier — e.g. "rtk" */
+  id: string;
+  /** Human-readable label shown in the report */
+  label: string;
+  /** Return structured data for display, or null when unavailable. */
+  getData: () => Record<string, string | number> | null;
+}
+
+const registry = createRegistry<ContextProvider>("context-provider-registry");
+
+/**
+ * Register a context data provider for an extension.
+ * Call during the extension factory function (not async handlers).
+ * Duplicate ids replace the previous registration.
+ */
+export function registerContextProvider(provider: ContextProvider): void {
+  registry.register(provider.id, provider);
+}
+
+/** Get all registered context providers in registration order. */
+export function getRegisteredContextProviders(): ContextProvider[] {
+  return registry.getAll();
+}
+
+/** Clear the registry — used by tests. */
+export function clearRegisteredContextProviders(): void {
+  registry.clear();
+}

package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-code-runtime/node_modules/@mrclrchtr/supi-core/src/context/context-tag.ts

@@ -0,0 +1,31 @@
+// XML context tag wrapping for SuPi extensions.
+//
+// Produces machine-parseable <extension-context> blocks that:
+// - Are LLM-friendly (structured XML)
+// - Carry metadata via attributes (source, file, turn, etc.)
+// - Can be reconstructed from session history via regex
+
+/**
+ * Wrap content in an `<extension-context>` XML tag.
+ *
+ * @param source - Extension identifier (e.g. "supi-claude-md", "supi-lsp")
+ * @param content - The text content to wrap
+ * @param attrs - Optional additional attributes (rendered as key="value")
+ * @returns Formatted XML string
+ */
+export function wrapExtensionContext(
+  source: string,
+  content: string,
+  attrs?: Record<string, string | number>,
+): string {
+  const attrParts = [`source="${source}"`];
+
+  if (attrs) {
+    for (const [key, value] of Object.entries(attrs)) {
+      attrParts.push(`${key}="${String(value)}"`);
+    }
+  }
+
+  const openTag = `<extension-context ${attrParts.join(" ")}>`;
+  return `${openTag}\n${content}\n</extension-context>`;
+}

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

@@ -0,0 +1,16 @@
+// supi-core context domain — context messages, providers, and XML tags.
+export type { ContextMessageLike } from "./context/context-messages.ts";
+export {
+  findLastUserMessageIndex,
+  getContextToken,
+  getPromptContent,
+  pruneAndReorderContextMessages,
+  restorePromptContent,
+} from "./context/context-messages.ts";
+export type { ContextProvider } from "./context/context-provider-registry.ts";
+export {
+  clearRegisteredContextProviders,
+  getRegisteredContextProviders,
+  registerContextProvider,
+} from "./context/context-provider-registry.ts";
+export { wrapExtensionContext } from "./context/context-tag.ts";

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

@@ -0,0 +1,255 @@
+// Shared debug event registry for SuPi extensions.
+//
+// Extensions record session-local diagnostic events here. The user-facing
+// supi-debug extension owns policy/configuration and exposes events through a
+// command/tool while this module stays dependency-free for producers.
+
+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;
+  /** What the agent-callable debug tool may return. */
+  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 {
+  source: string;
+  level: DebugLevel;
+  category: string;
+  message: string;
+  cwd?: string;
+  data?: unknown;
+  rawData?: unknown;
+}
+
+export interface DebugEvent extends DebugEventInput {
+  id: number;
+  timestamp: number;
+  data?: unknown;
+  rawData?: unknown;
+}
+
+export interface DebugEventQuery {
+  source?: string;
+  level?: DebugLevel;
+  category?: string;
+  limit?: number;
+  includeRaw?: boolean;
+  allowRaw?: boolean;
+}
+
+export interface DebugEventView {
+  id: number;
+  timestamp: number;
+  source: string;
+  level: DebugLevel;
+  category: string;
+  message: string;
+  cwd?: string;
+  data?: unknown;
+  rawData?: unknown;
+}
+
+export interface DebugEventQueryResult {
+  events: DebugEventView[];
+  rawAccessDenied: boolean;
+}
+
+export interface DebugSummary {
+  total: number;
+  byLevel: Partial<Record<DebugLevel, number>>;
+  bySource: Record<string, number>;
+}
+
+interface DebugRegistryState {
+  config: DebugRegistryConfig;
+  events: DebugEvent[];
+  nextId: number;
+}
+
+const REGISTRY_KEY = Symbol.for("@mrclrchtr/supi-core/debug-registry");
+const SECRET_KEY_RE = /(?:token|password|passwd|secret|api[_-]?key|authorization|credential)/i;
+const ENV_SECRET_RE =
+  /\b([A-Za-z0-9_]*(?:token|password|passwd|secret|api[_-]?key|authorization|credential)[A-Za-z0-9_]*)=(?:'[^']*'|"[^"]*"|\S+)/gi;
+const AUTH_HEADER_RE = /\b(authorization\s*[:=]\s*)(?:bearer\s+)?[^\s;&|]+/gi;
+const URL_SECRET_RE =
+  /([?&](?:token|password|passwd|secret|api[_-]?key|authorization|credential)=)[^&\s]+/gi;
+const REDACTED = "[REDACTED]";
+
+function cloneConfig(config: DebugRegistryConfig): DebugRegistryConfig {
+  return { ...config };
+}
+
+function getState(): DebugRegistryState {
+  let state = (globalThis as Record<symbol, unknown>)[REGISTRY_KEY] as
+    | DebugRegistryState
+    | undefined;
+  if (!state) {
+    state = {
+      config: cloneConfig(DEBUG_REGISTRY_DEFAULTS),
+      events: [],
+      nextId: 1,
+    };
+    (globalThis as Record<symbol, unknown>)[REGISTRY_KEY] = state;
+  }
+  return state;
+}
+
+function normalizeMaxEvents(value: number): number {
+  if (!Number.isFinite(value) || value <= 0) {
+    return DEBUG_REGISTRY_DEFAULTS.maxEvents;
+  }
+  return Math.floor(value);
+}
+
+function trimToMaxEvents(state: DebugRegistryState): void {
+  const maxEvents = normalizeMaxEvents(state.config.maxEvents);
+  if (state.events.length <= maxEvents) {
+    return;
+  }
+  state.events.splice(0, state.events.length - maxEvents);
+}
+
+function matchesQuery(event: DebugEvent, query: DebugEventQuery): boolean {
+  if (query.source && event.source !== query.source) return false;
+  if (query.level && event.level !== query.level) return false;
+  if (query.category && event.category !== query.category) return false;
+  return true;
+}
+
+function sanitizeString(value: string): string {
+  return value
+    .replace(ENV_SECRET_RE, (_match, key: string) => `${key}=${REDACTED}`)
+    .replace(AUTH_HEADER_RE, (_match, prefix: string) => `${prefix}${REDACTED}`)
+    .replace(URL_SECRET_RE, (_match, prefix: string) => `${prefix}${REDACTED}`);
+}
+
+function redactValue(value: unknown, depth: number): unknown {
+  if (depth <= 0) return "[MaxDepth]";
+  if (typeof value === "string") return sanitizeString(value);
+  if (typeof value !== "object" || value === null) return value;
+  if (Array.isArray(value)) return value.map((item) => redactValue(item, depth - 1));
+
+  const redacted: Record<string, unknown> = {};
+  for (const [key, item] of Object.entries(value)) {
+    redacted[key] = SECRET_KEY_RE.test(key) ? REDACTED : redactValue(item, depth - 1);
+  }
+  return redacted;
+}
+
+/** Configure the shared debug registry. Existing events are trimmed to the new max size. */
+export function configureDebugRegistry(config: Partial<DebugRegistryConfig>): DebugRegistryConfig {
+  const state = getState();
+  state.config = {
+    ...state.config,
+    ...config,
+    maxEvents: normalizeMaxEvents(config.maxEvents ?? state.config.maxEvents),
+  };
+  trimToMaxEvents(state);
+  return getDebugRegistryConfig();
+}
+
+/** Return the active debug registry configuration. */
+export function getDebugRegistryConfig(): DebugRegistryConfig {
+  return cloneConfig(getState().config);
+}
+
+/** Best-effort redaction helper for data exposed through sanitized debug views. */
+export function redactDebugData<T>(value: T): T {
+  return redactValue(value, 8) as T;
+}
+
+/** Record a session-local debug event if debugging is enabled. */
+export function recordDebugEvent(input: DebugEventInput): DebugEvent | null {
+  const state = getState();
+  if (!state.config.enabled) {
+    return null;
+  }
+
+  const event: DebugEvent = {
+    ...input,
+    id: state.nextId++,
+    timestamp: Date.now(),
+    data: input.data === undefined ? undefined : redactDebugData(input.data),
+  };
+  state.events.push(event);
+  trimToMaxEvents(state);
+  return { ...event };
+}
+
+/** Query retained debug events newest-first. Results are sanitized unless raw access is requested and allowed. */
+export function getDebugEvents(query: DebugEventQuery = {}): DebugEventQueryResult {
+  const state = getState();
+  const allowRaw = Boolean(
+    query.includeRaw && query.allowRaw && state.config.agentAccess === "raw",
+  );
+  const rawAccessDenied = Boolean(query.includeRaw && !allowRaw);
+  const limit = query.limit && query.limit > 0 ? Math.floor(query.limit) : state.config.maxEvents;
+
+  const events = state.events
+    .filter((event) => matchesQuery(event, query))
+    .slice()
+    .reverse()
+    .slice(0, limit)
+    .map((event): DebugEventView => {
+      const view: DebugEventView = {
+        id: event.id,
+        timestamp: event.timestamp,
+        source: event.source,
+        level: event.level,
+        category: event.category,
+        message: event.message,
+        cwd: event.cwd,
+        data: event.data,
+      };
+      if (allowRaw && event.rawData !== undefined) {
+        view.rawData = event.rawData;
+      }
+      return view;
+    });
+
+  return { events, rawAccessDenied };
+}
+
+/** Return aggregate debug counts suitable for summary displays. */
+export function getDebugSummary(): DebugSummary | null {
+  const events = getState().events;
+  if (events.length === 0) {
+    return null;
+  }
+
+  const summary: DebugSummary = { total: events.length, byLevel: {}, bySource: {} };
+  for (const event of events) {
+    summary.byLevel[event.level] = (summary.byLevel[event.level] ?? 0) + 1;
+    summary.bySource[event.source] = (summary.bySource[event.source] ?? 0) + 1;
+  }
+  return summary;
+}
+
+/** Clear retained events while preserving configuration. */
+export function clearDebugEvents(): void {
+  const state = getState();
+  state.events = [];
+}
+
+/** Reset the debug registry to defaults; intended for tests. */
+export function resetDebugRegistry(): void {
+  const state = getState();
+  state.config = cloneConfig(DEBUG_REGISTRY_DEFAULTS);
+  state.events = [];
+  state.nextId = 1;
+}

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

@@ -0,0 +1,30 @@
+// supi-core — shared infrastructure for SuPi extensions.
+// Provides XML context tag wrapping, unified config system, context-message utilities,
+// settings registry for supi-wide TUI settings, and a shared tool-spec/registration framework.
+//
+// Convenience barrel — re-exports all domain entry points.
+// For lighter imports, use one of the domain subpaths directly
+// (e.g. @mrclrchtr/supi-core/config, @mrclrchtr/supi-core/context).
+
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./config.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./context.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./debug-registry.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./path.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./project.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./session.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./settings.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./settings-ui.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./terminal.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./tool-framework.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./types.ts";