pi-subagents-lite 1.2.0 → 1.4.0

package/src/ui/menu/menu-spawn-wizard.ts

@@ -0,0 +1,418 @@
+/**
+ * menu-spawn-wizard.ts — Spawn agent wizard and worktree picker.
+ *
+ * Extracted from menus.ts to own the multi-step spawn composition flow:
+ * type selection → prompt → options sub-menu → spawn.
+ *
+ * The worktree picker (listWorktrees, isInGitRepo, parseWorktreeList, truncatePath)
+ * is co-located here because it exists solely to feed the spawn wizard's worktree_path.
+ */
+
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { SettingsList, SelectList, type SettingItem } from "@earendil-works/pi-tui";
+import type { ThinkingLevel } from "../../types.js";
+import { getAgentConfig, getAvailableTypes, resolveType, discoverNewAgents } from "../../agents/agent-types.js";
+import { findModelInRegistry } from "../../utils.js";
+import { buildSettingsListTheme, buildSelectListTheme } from "./helpers.js";
+import { DEFAULT_GRACE_TURNS } from "../../config/config-io.js";
+import { createModelSelectSubmenu } from "./submenus/model-select.js";
+import { createNumericSubmenu, createInputSubmenu } from "./submenus/numeric-input.js";
+import { SettingsListWrapper } from "./wrappers/settings-list.js";
+import {
+  getPiInstance,
+  getSessionCtx,
+  getWidget,
+  getStore,
+  getCoordinator,
+} from "../../shell.js";
+
+// ============================================================================
+// Worktree picker helpers
+// ============================================================================
+
+/** Timeout for git worktree list command (ms). */
+const WORKTREE_LIST_TIMEOUT_MS = 5000;
+
+/** Max display length for a worktree path before truncation. */
+const WORKTREE_PATH_TRUNCATE_LEN = 60;
+
+interface WorktreeEntry {
+  path: string;
+  branch: string | null;
+  isDetached: boolean;
+}
+
+/**
+ * Parse `git worktree list --porcelain` output into structured entries.
+ *
+ * Format (one block per worktree, separated by blank lines):
+ *   worktree /path/to/worktree
+ *   HEAD <sha>
+ *   branch refs/heads/<name>   (or: (detached))
+ */
+function parseWorktreeList(output: string): WorktreeEntry[] {
+  const entries: WorktreeEntry[] = [];
+  const blocks = output.split(/\n\n+/);
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+    const lines = block.split("\n");
+    let path = "";
+    let branch: string | null = null;
+    let isDetached = false;
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        path = line.slice("worktree ".length);
+      } else if (line.startsWith("branch refs/heads/")) {
+        branch = line.slice("branch refs/heads/".length);
+      } else if (line === "detached") {
+        isDetached = true;
+      }
+    }
+    if (path) {
+      entries.push({ path, branch, isDetached });
+    }
+  }
+  return entries;
+}
+
+/** Truncate a path for display, keeping the tail. */
+function truncatePath(p: string): string {
+  if (p.length <= WORKTREE_PATH_TRUNCATE_LEN) return p;
+  return "..." + p.slice(p.length - WORKTREE_PATH_TRUNCATE_LEN + 3);
+}
+
+/**
+ * Fetch worktrees via `git worktree list --porcelain`.
+ * Returns null if git is unavailable or the command fails.
+ */
+async function listWorktrees(cwd: string): Promise<WorktreeEntry[] | null> {
+  try {
+    const result = await getPiInstance().exec(
+      "git",
+      ["worktree", "list", "--porcelain"],
+      { cwd, timeout: WORKTREE_LIST_TIMEOUT_MS },
+    );
+    if (result.code !== 0) return null;
+    return parseWorktreeList(result.stdout);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check whether a directory is inside a git repository.
+ * Uses `git rev-parse --git-common-dir` — the same strategy as the worktree validator.
+ */
+async function isInGitRepo(cwd: string): Promise<boolean> {
+  try {
+    const result = await getPiInstance().exec(
+      "git",
+      ["rev-parse", "--git-common-dir"],
+      { cwd, timeout: WORKTREE_LIST_TIMEOUT_MS },
+    );
+    return result.code === 0 && result.stdout.trim() !== "";
+  } catch {
+    return false;
+  }
+}
+
+// ============================================================================
+// Spawn agent wizard
+// ============================================================================
+
+const THINKING_LEVELS: ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh"];
+
+/**
+ * Show the spawn agent flow as a multi-step wizard:
+ *   Step 1: type selection (SelectList)
+ *   Step 2: prompt entry (Input)
+ *   Step 3: options sub-menu with spawn (SettingsList with submenus)
+ */
+export async function showSpawnAgentMenu(
+  ctx: ExtensionCommandContext,
+  modelOptions: string[],
+): Promise<void> {
+  // ---- Step 1: Type selection ----
+  let selectedType: string;
+  {
+    const types = getAvailableTypes();
+    if (types.length === 0) {
+      ctx.ui.notify("No agent types available", "error");
+      return;
+    }
+
+    const result = await ctx.ui.custom<string | undefined>((_tui, theme, _kb, done) => {
+      const items: SettingItem[] = types.map(t => ({
+        id: t,
+        label: t,
+        currentValue: t,
+        submenu: (_v: string, _subDone: (value?: string) => void) => {
+          done(t);
+          return undefined as any;
+        },
+      }));
+      const list = new SettingsList(
+        items,
+        10,
+        buildSettingsListTheme(theme),
+        (id, value) => { done(value); },
+        () => done(undefined),
+        { enableSearch: true },
+      );
+      return new SettingsListWrapper(list, { title: "Select Agent Type", theme, passthroughKeys: true });
+    });
+    if (result === undefined) return;
+
+    const config = getAgentConfig(result);
+    if (!config) {
+      ctx.ui.notify(`Unknown agent type: ${result}`, "error");
+      return;
+    }
+    selectedType = result;
+  }
+
+  const agentConfig = getAgentConfig(selectedType)!;
+
+  // ---- Step 2: Prompt entry ----
+  let prompt: string;
+  {
+    const result = await ctx.ui.custom<string | undefined>((_tui, theme, _kb, done) => {
+      const input = createInputSubmenu(ctx, { required: true })("", done);
+      return new SettingsListWrapper(input, { title: "Agent Prompt", theme, passthroughKeys: true });
+    });
+    if (result === undefined) return;
+    prompt = result;
+  }
+
+  // ---- Step 3: Options sub-menu with spawn ----
+  const session = getSessionCtx();
+  const parentCwd = session?.cwd ?? "";
+  const inGitRepo = parentCwd ? await isInGitRepo(parentCwd) : false;
+  const worktrees = inGitRepo ? (await listWorktrees(parentCwd)) ?? [] : [];
+
+  const store = getStore();
+  const parentModelId = session?.model
+    ? `${session.model.provider}/${session.model.id}`
+    : "";
+  const effectiveModelStr = store.modelFor(selectedType, parentModelId, agentConfig);
+
+  let currentModelStr = effectiveModelStr || "";
+  let currentThinking: ThinkingLevel | undefined = agentConfig.thinkingLevel ?? store.agent.defaultThinking;
+  let currentMaxTurns: number | undefined = agentConfig.maxTurns ?? store.agent.defaultMaxTurns;
+  let currentMaxTokens: number | undefined = agentConfig.maxTokens;
+  let currentGraceTurns: number = store.agent.graceTurns ?? DEFAULT_GRACE_TURNS;
+  let currentBackground: boolean = store.agent.forceBackground;
+  let currentWorktreePath: string | undefined;
+  let currentWorktreeLabel = "Inherits parent cwd";
+  let currentDescription = prompt.length > 50 ? prompt.slice(0, 50) : prompt;
+
+  const buildItems = (): SettingItem[] => {
+    const fmtNum = (v: number | undefined) => v != null ? String(v) : "(not set)";
+    const displayModel = currentModelStr || "(inherits parent)";
+    const items: SettingItem[] = [
+      {
+        id: "spawn",
+        label: "Spawn",
+        currentValue: "",
+        submenu: (_v, done) => {
+          const gtItem = items.find(i => i.id === "graceTurns");
+          const bgItem = items.find(i => i.id === "background");
+          const descItem = items.find(i => i.id === "description");
+          const promptItem = items.find(i => i.id === "prompt");
+
+          const thinking = currentThinking;
+          const maxTurns = currentMaxTurns;
+          const maxTokens = currentMaxTokens;
+          const graceTurns = Number(gtItem?.currentValue ?? DEFAULT_GRACE_TURNS);
+          const background = bgItem?.currentValue === "ON";
+          const description = descItem?.currentValue ?? currentDescription;
+          const spawnPrompt = promptItem?.currentValue ?? prompt;
+
+          // Resolve model
+          let model: ReturnType<typeof findModelInRegistry> = undefined;
+          let modelKey: string | undefined;
+          if (currentModelStr) {
+            const registry = session?.modelRegistry ?? ctx.modelRegistry;
+            model = findModelInRegistry(currentModelStr, registry, undefined);
+            if (!model) {
+              ctx.ui.notify(`Model not found: ${currentModelStr}`, "error");
+              done();
+              return undefined as any;
+            }
+            modelKey = `${model.provider}/${model.id}`;
+          }
+
+          const doSpawn = async () => {
+            if (currentWorktreePath) {
+              await discoverNewAgents(`${currentWorktreePath}/.pi/agents`);
+            }
+            const resolvedType = resolveType(selectedType) ?? selectedType;
+
+            const widget = getWidget();
+            if (widget) {
+              widget.setUICtx(ctx.ui as unknown as import("../agent-widget.js").UICtx);
+              widget.ensureTimer();
+            }
+
+            const coordinator = getCoordinator()!;
+            try {
+              const result = await coordinator.spawn(getPiInstance(), session!, {
+                type: resolvedType,
+                prompt: spawnPrompt,
+                description,
+                model,
+                modelKey,
+                maxTurns,
+                maxTokens,
+                thinkingLevel: thinking,
+                graceTurns,
+                worktreePath: currentWorktreePath,
+                worktreeLabel: currentWorktreePath ? currentWorktreeLabel : undefined,
+                invocation: {
+                  modelName: model?.id,
+                  thinkingLevel: thinking,
+                  maxTurns,
+                  runInBackground: background,
+                },
+                runInBackground: background,
+              });
+
+              if (!background) {
+                getWidget()?.markFinished(result.agentId);
+                getWidget()?.update();
+              }
+            } catch (err) {
+              ctx.ui.notify(
+                `Spawn failed: ${err instanceof Error ? err.message : String(err)}`,
+                "error",
+              );
+            }
+          };
+
+          done();
+          doneRef();
+          doSpawn().catch(() => {});
+          return undefined as any;
+        },
+      },
+      {
+        id: "__sep__",
+        label: " ",
+        currentValue: "",
+      },
+      {
+        id: "model",
+        label: "Model",
+        currentValue: displayModel,
+        submenu: createModelSelectSubmenu({
+          modelOptions,
+          showClear: false,
+          theme,
+          onSelect: (_mode, model) => {
+            currentModelStr = model === "(inherits parent)" || model === null ? "" : model;
+          },
+        }),
+      },
+      {
+        id: "background",
+        label: "Background",
+        currentValue: currentBackground ? "ON" : "OFF",
+        values: ["ON", "OFF"],
+      },
+      ...(inGitRepo
+        ? [{
+            id: "worktree",
+            label: "Worktree",
+            currentValue: currentWorktreeLabel,
+            submenu: (_v: string, done: (v?: string) => void) => {
+              const pickerItems = [
+                { value: "Inherits parent cwd", label: "Inherits parent cwd" },
+                ...worktrees.map(wt => {
+                  const branchLabel = wt.isDetached ? "detached" : (wt.branch ?? "detached");
+                  const truncPath = truncatePath(wt.path);
+                  return { value: wt.path, label: `${branchLabel}  ·  ${truncPath}` };
+                }),
+              ];
+              const list = new SelectList(pickerItems, 10, buildSelectListTheme(theme));
+              list.onSelect = (item) => {
+                if (item.value === "Inherits parent cwd") {
+                  currentWorktreePath = undefined;
+                  done("Inherits parent cwd");
+                } else {
+                  const wt = worktrees.find(w => w.path === item.value);
+                  currentWorktreePath = wt?.path;
+                  done(wt?.branch ?? "detached");
+                }
+              };
+              list.onCancel = () => done();
+              return list;
+            },
+          } as SettingItem]
+        : []),
+      {
+        id: "thinkingLevel",
+        label: "Thinking level",
+        currentValue: currentThinking ?? "inherit",
+        values: [...THINKING_LEVELS, "inherit"],
+      },
+      {
+        id: "maxTokens",
+        label: "Max tokens",
+        currentValue: fmtNum(currentMaxTokens),
+        submenu: createNumericSubmenu(ctx, (parsed) => { currentMaxTokens = parsed; }, () => { currentMaxTokens = undefined; }),
+      },
+      {
+        id: "maxTurns",
+        label: "Max turns",
+        currentValue: fmtNum(currentMaxTurns),
+        submenu: createNumericSubmenu(ctx, (parsed) => { currentMaxTurns = parsed; }, () => { currentMaxTurns = undefined; }),
+      },
+      {
+        id: "graceTurns",
+        label: "Grace turns",
+        currentValue: String(currentGraceTurns),
+        submenu: createNumericSubmenu(ctx, { min: 0, default: DEFAULT_GRACE_TURNS }, (parsed) => { currentGraceTurns = parsed; }),
+      },
+      { id: "__sep__", label: " ", currentValue: "" },
+      {
+        id: "description",
+        label: "Description",
+        currentValue: currentDescription,
+        submenu: createInputSubmenu(ctx),
+      },
+      {
+        id: "prompt",
+        label: "Prompt",
+        currentValue: prompt,
+        submenu: createInputSubmenu(ctx, { required: true }),
+      }
+    ];
+
+    return items;
+  };
+
+  let theme: any;
+  let doneRef: () => void;
+
+  await ctx.ui.custom((_tui, t, _kb, done) => {
+    theme = t;
+    doneRef = () => done(undefined);
+
+    const items = buildItems();
+    const onChange = (id: string, newValue: string) => {
+      switch (id) {
+        case "thinkingLevel":
+          currentThinking = newValue === "inherit" ? undefined : newValue as ThinkingLevel;
+          break;
+        case "background":
+          currentBackground = newValue === "ON";
+          break;
+        case "prompt":
+          prompt = newValue;
+        break;
+      }
+    };
+    const settingsList = new SettingsList(items, 15, buildSettingsListTheme(theme), onChange, doneRef);
+    return new SettingsListWrapper(settingsList, { title: "Spawn Options", theme, onCancel: () => doneRef() });
+  });
+}

package/src/ui/menu/menu-system-prompt.ts

@@ -0,0 +1,109 @@
+/**
+ * menu-system-prompt.ts — System prompt settings menu concern.
+ *
+ * Uses SettingsList from @earendil-works/pi-tui via ctx.ui.custom.
+ * SettingsList maintains internal cursor state, fixing the cursor-position
+ * reset bug that occurred with ctx.ui.select.
+ *
+ * Exports:
+ *   - showSystemPromptMenu: system prompt mode, create prompt file, include AGENTS.md
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { SettingsList, type SettingItem } from "@earendil-works/pi-tui";
+import { buildSettingsListTheme } from "./helpers.js";
+import { SettingsListWrapper } from "./wrappers/settings-list.js";
+import type { SystemPromptMode } from "../../agents/types.js";
+import { getStore } from "../../shell.js";
+import { CUSTOM_PROMPT_PATH } from "../../agents/agent-runner.js";
+
+export async function showSystemPromptMenu(ctx: ExtensionCommandContext): Promise<void> {
+  const store = getStore();
+
+  const buildItems = (): SettingItem[] => {
+    const items: SettingItem[] = [
+      {
+        id: "systemPromptMode",
+        label: "System prompt mode",
+        currentValue: store.agent.systemPromptMode,
+        values: ["replace", "inherit", "custom"],
+      },
+    ];
+
+    // Create prompt file (only when mode is custom and file doesn't exist)
+    if (store.agent.systemPromptMode === "custom" && !fs.existsSync(CUSTOM_PROMPT_PATH)) {
+      items.push({
+        id: "createPromptFile",
+        label: "Create prompt file",
+        currentValue: CUSTOM_PROMPT_PATH,
+        values: ["Create"],
+      });
+    }
+
+    items.push(
+      {
+        id: "includeContextFiles",
+        label: "Include AGENTS.md",
+        currentValue: store.agent.includeContextFiles ? "ON" : "OFF",
+        values: ["ON", "OFF"],
+      },
+      {
+        id: "loadSkillsImplicitly",
+        label: "Load skills implicitly",
+        currentValue: store.agent.loadSkillsImplicitly ? "ON" : "OFF",
+        values: ["ON", "OFF"],
+      },
+      {
+        id: "loadExtensionsImplicitly",
+        label: "Load extensions implicitly",
+        currentValue: store.agent.loadExtensionsImplicitly ? "ON" : "OFF",
+        values: ["ON", "OFF"],
+      },
+    );
+
+    return items;
+  };
+
+  let items = buildItems();
+  let rebuild: ((newItems: SettingItem[]) => void) | null = null;
+
+  const onChange = (id: string, newValue: string) => {
+    switch (id) {
+      case "systemPromptMode":
+        store.mutate.agent.setSystemPromptMode(newValue as SystemPromptMode);
+        ctx.ui.notify(`System prompt mode set to ${newValue}`, "info");
+        // Rebuild: "custom" adds the create prompt file item, other modes remove it.
+        items = buildItems();
+        rebuild?.(items);
+        break;
+      case "createPromptFile":
+        try {
+          fs.mkdirSync(path.dirname(CUSTOM_PROMPT_PATH), { recursive: true });
+          fs.writeFileSync(CUSTOM_PROMPT_PATH, "You are a Pi, an expert coding sub-agent.\nYou have been invoked to handle a specific task autonomously", "utf-8");
+          ctx.ui.notify(`Created prompt file: ${CUSTOM_PROMPT_PATH}`, "info");
+        } catch (err: any) {
+          ctx.ui.notify(`Failed to create prompt file: ${err.message}`, "error");
+        }
+        return;
+      case "includeContextFiles":
+        store.mutate.agent.setIncludeContextFiles(newValue === "ON");
+        ctx.ui.notify(`Include AGENTS.md set to ${newValue}`, "info");
+        break;
+      case "loadSkillsImplicitly":
+        store.mutate.agent.setLoadSkillsImplicitly(newValue === "ON");
+        ctx.ui.notify(`Load skills implicitly set to ${newValue}`, "info");
+        break;
+      case "loadExtensionsImplicitly":
+        store.mutate.agent.setLoadExtensionsImplicitly(newValue === "ON");
+        ctx.ui.notify(`Load extensions implicitly set to ${newValue}`, "info");
+        break;
+    }
+  };
+
+  await ctx.ui.custom((_tui, theme, _kb, done) => {
+    const settingsList = new SettingsList(items, 10, buildSettingsListTheme(theme), onChange, () => done(undefined));
+    return new SettingsListWrapper(settingsList, { title: "System Prompt", theme, onCancel: () => done(undefined), onRebuild: (r) => { rebuild = r; } });
+  });
+}

package/src/ui/menu/menu-widget-settings.ts

@@ -0,0 +1,130 @@
+/**
+ * menu-widget-settings.ts — Widget settings menu concern.
+ *
+ * Uses SettingsList from @earendil-works/pi-tui via ctx.ui.custom.
+ * SettingsList maintains internal cursor state, fixing the cursor-position
+ * reset bug that occurred with ctx.ui.select.
+ *
+ * Structure:
+ *   Main list: compact, maxLines, descLengthFull, maxLinesCompact, descLengthCompact, shortcut, usageStats
+ *   Usage stats submenu: 7 stat visibility toggles
+ *
+ * Exports:
+ *   - showWidgetSettingsMenu
+ */
+
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { SettingsList, type SettingItem } from "@earendil-works/pi-tui";
+import { buildSettingsListTheme } from "./helpers.js";
+import { createNumericSubmenu } from "./submenus/numeric-input.js";
+import { SettingsListWrapper } from "./wrappers/settings-list.js";
+import { getStore } from "../../shell.js";
+
+/** Stat visibility config — label and store accessors keyed by stat id. */
+function buildStatConfig(store: ReturnType<typeof getStore>) {
+  return new Map<string, { label: string; get: () => boolean; set: (v: boolean) => void }>([
+    ["showTools", { label: "Show tools", get: () => store.agent.showTools, set: (v) => store.mutate.agent.setShowTools(v) }],
+    ["showTurns", { label: "Show turns", get: () => store.agent.showTurns, set: (v) => store.mutate.agent.setShowTurns(v) }],
+    ["showInput", { label: "Show input tokens", get: () => store.agent.showInput, set: (v) => store.mutate.agent.setShowInput(v) }],
+    ["showOutput", { label: "Show output tokens", get: () => store.agent.showOutput, set: (v) => store.mutate.agent.setShowOutput(v) }],
+    ["showContext", { label: "Show context %", get: () => store.agent.showContext, set: (v) => store.mutate.agent.setShowContext(v) }],
+    ["showCost", { label: "Show cost", get: () => store.agent.showCost, set: (v) => store.mutate.agent.setShowCost(v) }],
+    ["showTime", { label: "Show time", get: () => store.agent.showTime, set: (v) => store.mutate.agent.setShowTime(v) }],
+  ]);
+}
+
+export async function showWidgetSettingsMenu(ctx: ExtensionCommandContext): Promise<void> {
+  const store = getStore();
+  const statConfig = buildStatConfig(store);
+
+  const onChange = (id: string, newValue: string) => {
+    const stat = statConfig.get(id);
+    if (stat) {
+      stat.set(newValue === "ON");
+      ctx.ui.notify(`${stat.label} ${newValue}`, "info");
+      return;
+    }
+
+    switch (id) {
+      case "compact":
+        store.mutate.widget.setCompact(newValue === "ON");
+        ctx.ui.notify(`Force compact mode ${newValue}`, "info");
+        break;
+      case "shortcut":
+        store.mutate.widget.setShortcut(newValue === "ON");
+        ctx.ui.notify(`Ctrl+o shortcut ${newValue}`, "info");
+        break;
+    }
+  };
+
+  await ctx.ui.custom((_tui, theme, _kb, done) => {
+    const statItems: SettingItem[] = [...statConfig.entries()].map(([id, cfg]) => ({
+      id,
+      label: cfg.label,
+      currentValue: cfg.get() ? "ON" : "OFF",
+      values: ["ON", "OFF"],
+    }));
+
+    const items: SettingItem[] = [
+      {
+        id: "compact",
+        label: "Force compact mode",
+        currentValue: store.agent.widgetCompact ? "ON" : "OFF",
+        values: ["ON", "OFF"],
+      },
+      {
+        id: "maxLines",
+        label: "Max lines (full)",
+        currentValue: String(store.agent.widgetMaxLines),
+        submenu: createNumericSubmenu(ctx, { min: 2 }, (parsed) => {
+          store.mutate.widget.setMaxLines(parsed);
+          ctx.ui.notify(`Max lines (full) set to ${parsed}`, "info");
+        }),
+      },
+      {
+        id: "descLengthFull",
+        label: "Description length (full)",
+        currentValue: String(store.agent.widgetDescLengthFull),
+        submenu: createNumericSubmenu(ctx, { min: 5 }, (parsed) => {
+          store.mutate.widget.setDescLengthFull(parsed);
+          ctx.ui.notify(`Description length (full) set to ${parsed}`, "info");
+        }),
+      },
+      {
+        id: "maxLinesCompact",
+        label: "Max lines (compact)",
+        currentValue: String(store.agent.widgetMaxLinesCompact),
+        submenu: createNumericSubmenu(ctx, (parsed) => {
+          store.mutate.widget.setMaxLinesCompact(parsed);
+          ctx.ui.notify(`Max lines (compact) set to ${parsed}`, "info");
+        }),
+      },
+      {
+        id: "descLengthCompact",
+        label: "Description length (compact)",
+        currentValue: String(store.agent.widgetDescLengthCompact),
+        submenu: createNumericSubmenu(ctx, { min: 5 }, (parsed) => {
+          store.mutate.widget.setDescLengthCompact(parsed);
+          ctx.ui.notify(`Description length (compact) set to ${parsed}`, "info");
+        }),
+      },
+      {
+        id: "shortcut",
+        label: "Ctrl+o shortcut",
+        currentValue: store.agent.widgetShortcut ? "ON" : "OFF",
+        values: ["ON", "OFF"],
+      },
+      { id: "__sep__", label: " ", currentValue: "" },
+      {
+        id: "usageStats",
+        label: "Usage stats",
+        currentValue: "→",
+        submenu: (_currentValue, done2) =>
+          new SettingsList(statItems, 7, buildSettingsListTheme(theme), onChange, () => done2()),
+      },
+    ];
+
+    const settingsList = new SettingsList(items, 15, buildSettingsListTheme(theme), onChange, () => done(undefined));
+    return new SettingsListWrapper(settingsList, { title: "Widget Settings", theme, onCancel: () => done(undefined) });
+  });
+}