pi-subagents-lite 1.2.0 → 1.4.0

package/src/ui/menu/menu-concurrency.ts

@@ -0,0 +1,192 @@
+/**
+ * menu-concurrency.ts — Concurrency settings menu concern.
+ *
+ * Uses SettingsList from @earendil-works/pi-tui via ctx.ui.custom.
+ * Numeric input submenus for concurrency values.
+ * Confirm submenu for reset all.
+ *
+ * Exports:
+ *   - showConcurrencySettingsMenu: per-provider and per-model slot limits
+ */
+
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { SettingsList, SelectList, type SettingItem } from "@earendil-works/pi-tui";
+import { buildSettingsListTheme, buildSelectListTheme, createDelegatingComponent } from "./helpers.js";
+import { createNumericSubmenu } from "./submenus/numeric-input.js";
+import { createConfirmSubmenu } from "./submenus/confirm.js";
+import { SettingsListWrapper } from "./wrappers/settings-list.js";
+import { getStore } from "../../shell.js";
+
+export async function showConcurrencySettingsMenu(
+  ctx: ExtensionCommandContext,
+  modelOptions: string[],
+): Promise<void> {
+  // Build menu items from current store state.
+  const buildItems = (store: ReturnType<typeof getStore>, theme: any, modelOptions: string[], onRebuild?: () => void): SettingItem[] => {
+    const providers = [...new Set(modelOptions.map((m) => m.split("/")[0]))].sort();
+    const items: SettingItem[] = [];
+
+    
+
+    // Submenu factory: pick Edit (→ value input) or Remove for an existing limit.
+    const editOrRemoveSubmenu = (
+      currentLimit: number,
+      onEdit: (parsed: number) => void,
+      onRemove: () => void,
+    ): SettingItem["submenu"] => (_currentValue, subDone) => {
+      const list = new SelectList(
+        [{ value: "edit", label: "Edit limit" }, { value: "remove", label: "Remove limit" }],
+        5, buildSelectListTheme(theme),
+      );
+      const delegator = createDelegatingComponent(list);
+      list.onSelect = (item) => {
+        if (item.value === "edit") {
+          delegator.setActive(createNumericSubmenu(ctx, { min: 1 }, onEdit)(String(currentLimit), subDone));
+        } else {
+          onRemove();
+          subDone();
+          onRebuild?.();
+        }
+      };
+      list.onCancel = () => subDone();
+      return delegator;
+    };
+
+    // Submenu factory: pick a key from `options`, then enter a value.
+    const addLimitSubmenu = (
+      options: string[],
+      onPick: (key: string, parsed: number) => void,
+    ): SettingItem["submenu"] => (_currentValue, subDone) => {
+      const list = new SelectList(
+        options.map((o) => ({ value: o, label: o })),
+        10, buildSelectListTheme(theme),
+      );
+      const delegator = createDelegatingComponent(list);
+      list.onSelect = (item) => {
+        delegator.setActive(createNumericSubmenu(ctx, { min: 1 }, (parsed) => onPick(item.value, parsed))("1", subDone));
+      };
+      list.onCancel = () => subDone();
+      return delegator;
+    };
+
+    // Global default
+    items.push({
+      id: "defaultConcurrency",
+      label: "Default concurrency limit",
+      currentValue: String(store.concurrency.default),
+      submenu: createNumericSubmenu(ctx, (parsed) => {
+        store.mutate.concurrency.setDefault(parsed);
+        ctx.ui.notify(`Default concurrency set to ${parsed}`, "info");
+      }),
+    });
+
+    // Per-provider limits
+    items.push({ id: "__sep__", label: " ", currentValue: "" });
+    items.push({ id: "__sep__", label: "── Per-provider limits ──", currentValue: "────────" });
+    const providerLimits = store.concurrency.providers;
+    for (const provider of Object.keys(providerLimits)) {
+      const limit = providerLimits[provider];
+      items.push({
+        id: `provider:${provider}`,
+        label: provider,
+        currentValue: `${limit} slots`,
+        submenu: editOrRemoveSubmenu(
+          limit,
+          (parsed) => {
+            store.mutate.concurrency.setProvider(provider, parsed);
+            ctx.ui.notify(`${provider} concurrency set to ${parsed}`, "info");
+          },
+          () => {
+            store.mutate.concurrency.removeProvider(provider);
+            ctx.ui.notify(`Removed per-provider limit for ${provider}`, "info");
+          },
+        ),
+      });
+    }
+
+    items.push({ id: "__sep__", label: "─────────────────────────", currentValue: "────────" });
+    // Add per-provider limit (submenu: provider selection → numeric input)
+    if (providers.length > 0) {
+      items.push({
+        id: "addProviderLimit",
+        label: "Add per-provider limit...",
+        currentValue: "",
+        submenu: addLimitSubmenu(providers, (provider, parsed) => {
+          store.mutate.concurrency.setProvider(provider, parsed);
+          ctx.ui.notify(`${provider} concurrency set to ${parsed}`, "info");
+        }),
+      });
+    }
+
+    // Per-model limits
+    items.push({ id: "__sep__", label: " ", currentValue: "" });
+    items.push({ id: "__sep__", label: "── Per-model limits ──", currentValue: "────────" });
+    const models = store.concurrency.models;
+    for (const modelKey of Object.keys(models)) {
+      const limit = models[modelKey];
+      items.push({
+        id: `model:${modelKey}`,
+        label: modelKey,
+        currentValue: `${limit} slots`,
+        submenu: editOrRemoveSubmenu(
+          limit,
+          (parsed) => {
+            store.mutate.concurrency.setModel(modelKey, parsed);
+            ctx.ui.notify(`${modelKey} concurrency set to ${parsed}`, "info");
+          },
+          () => {
+            store.mutate.concurrency.removeModel(modelKey);
+            ctx.ui.notify(`Removed per-model limit for ${modelKey}`, "info");
+          },
+        ),
+      });
+    }
+
+    // Add per-model limit
+    items.push({ id: "__sep__", label: "─────────────────────────", currentValue: "────────" });
+    if (modelOptions.length > 0) {
+      items.push({
+        id: "addModelLimit",
+        label: "Add per-model limit...",
+        currentValue: "",
+        submenu: addLimitSubmenu(modelOptions, (modelKey, parsed) => {
+          store.mutate.concurrency.setModel(modelKey, parsed);
+          ctx.ui.notify(`${modelKey} concurrency set to ${parsed}`, "info");
+        }),
+      });
+    }
+
+    // Reset all to defaults
+    items.push({ id: "__sep__", label: " ", currentValue: "" });
+    items.push({
+      id: "resetAll",
+      label: "Reset all to defaults",
+      currentValue: "",
+      submenu: createConfirmSubmenu({
+        message: "Reset all concurrency limits to defaults?",
+        theme,
+        onConfirm: () => {
+          store.mutate.concurrency.reset();
+          ctx.ui.notify("Concurrency reset to defaults", "info");
+        },
+      }),
+    });
+
+    return items;
+  };
+
+  let rebuild: ((items: any[]) => void) | undefined;
+
+  await ctx.ui.custom((_tui, theme, _kb, done) => {
+    const triggerRebuild = () => rebuild?.(buildItems(getStore(), theme, modelOptions, triggerRebuild));
+    const store = getStore();
+    const items = buildItems(store, theme, modelOptions, triggerRebuild);
+    const settingsList = new SettingsList(items, 15, buildSettingsListTheme(theme), (_id, _v) => triggerRebuild(), () => done(undefined));
+    return new SettingsListWrapper(settingsList, {
+      title: "Concurrency Settings",
+      theme,
+      onCancel: () => done(undefined),
+      onRebuild: (r) => { rebuild = r; },
+    });
+  });
+}

package/src/ui/menu/menu-debug.ts

@@ -0,0 +1,125 @@
+/**
+ * menu-debug.ts — Debug menu concern.
+ *
+ * Uses SelectList from @earendil-works/pi-tui via ctx.ui.custom.
+ * Items: Agent types (notify), Agent briefing (send to LLM).
+ * Actions execute on select; Escape closes the menu.
+ *
+ * Exports:
+ *   - showDebugMenu: agent types listing, agent briefing
+ *
+ * Private helpers (single-consumer, co-located):
+ *   - showAgentTypes: list available agent types and their configs
+ *   - handleAgentBriefing: send agent types/capabilities info to LLM
+ */
+
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { SelectList, type SelectItem } from "@earendil-works/pi-tui";
+import { getAgentConfig, getAvailableTypes, getAllTypes } from "../../agents/agent-types.js";
+import { buildSelectListTheme } from "./helpers.js";
+import { SettingsListWrapper } from "./wrappers/settings-list.js";
+import { getPiInstance } from "../../shell.js";
+
+async function showAgentTypes(ctx: ExtensionCommandContext): Promise<void> {
+  const types = getAllTypes();
+  if (types.length === 0) {
+    ctx.ui.notify("No agent types available", "info");
+    return;
+  }
+
+  const lines: string[] = ["Available agent types:\n"];
+  for (const name of types) {
+    const cfg = getAgentConfig(name);
+    if (!cfg) continue;
+    const hidden = cfg.hidden === true ? " [HIDDEN]" : "";
+    const model = cfg.model ? `  Model: ${cfg.model}` : "";
+    const tools = cfg.registeredTools
+      ? `  Tools: ${cfg.registeredTools.join(", ")}`
+      : "  Tools: all built-in tools";
+    const source = cfg.source ? `  Source: ${cfg.source}` : "";
+    lines.push(`  ${name}${hidden}`);
+    lines.push(`    ${cfg.description}`);
+    if (model) lines.push(model);
+    lines.push(tools);
+    if (source) lines.push(source);
+    lines.push("");
+  }
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+async function handleAgentBriefing(ctx: ExtensionCommandContext): Promise<void> {
+  const types = getAvailableTypes();
+  const agents = types.map((t) => ({ name: t, config: getAgentConfig(t) }));
+
+  const lines: string[] = [
+    "# Agent Types and Capabilities\n",
+    "The following agent types are available. Use the `agent` parameter to select one.\n",
+  ];
+
+  for (const { name, config } of agents) {
+    if (!config) continue;
+    lines.push(`## ${config.displayName ?? name}`);
+    lines.push(config.description);
+    lines.push("");
+
+    if (config.registeredTools) {
+      lines.push(`**Tools:** ${config.registeredTools.join(", ")}`);
+    }
+    if (config.model) {
+      lines.push(`**Default model:** ${config.model}`);
+    }
+    if (config.maxTurns) {
+      lines.push(`**Max turns:** ${config.maxTurns}`);
+    }
+    lines.push("");
+  }
+
+  // Parameter descriptions
+  lines.push("## Agent Tool Parameters\n");
+  lines.push("| Parameter | Description |");
+  lines.push("|-----------|-------------|");
+  lines.push("| `prompt` | The task for the agent (required) |");
+  lines.push("| `description` | One-line summary of what the agent should do (required) |");
+  lines.push("| `agent` | Which agent type to use (default: general-purpose) |");
+  lines.push("| `thinking` | Optional thinking mode override (e.g., `off`, `minimal`, `low`, `medium`, `high`, `xhigh`) |");
+  lines.push("| `run_in_background` | When `true`, result is auto-delivered — do NOT poll. Continue working while waiting. |");
+  lines.push("| `worktree_path` | Optional path to a git worktree of the parent's repo. See below for details. |");
+  lines.push("");
+
+  // Usage guidelines
+  lines.push("## Usage Guidelines\n");
+  lines.push("- Agents start fresh with their config — they do NOT inherit the parent conversation");
+  lines.push("- For parallel tasks, spawn multiple `run_in_background: true` agents in one turn");
+  lines.push("  → Results are auto-delivered — do NOT poll, the result will arrive when ready");
+  lines.push("");
+  lines.push("## `worktree_path` Parameter\n");
+  lines.push("Use `worktree_path` to run a subagent in a different git worktree of the parent's repository.");
+  lines.push("");
+  lines.push("- **Optional.** Omit to run the subagent in the parent's working directory (default behavior).");
+  lines.push("- **Must be a path** inside a git worktree of the parent's repo, including the main checkout. Not a different repo, not a non-git directory.");
+  lines.push("- **Relative paths** are resolved against the parent's working directory.");
+  lines.push("- **On failure** the validator returns a specific reason (e.g., 'not a worktree of the parent's repository', 'path does not exist') — use this to self-correct.");
+  lines.push("- **Agent type discovery:** The worktree's `.pi/agents/` directory is scanned for agent types when this param is set, so worktree-local types become available to that spawn.");
+  getPiInstance().sendUserMessage(lines.join("\n"));
+  ctx.ui.notify("Agent briefing sent to LLM", "info");
+}
+
+export async function showDebugMenu(ctx: ExtensionCommandContext): Promise<void> {
+  await ctx.ui.custom((_tui, theme, _kb, done) => {
+    const items: SelectItem[] = [
+      { value: "agent-types", label: "Agent types", description: "List available agent types and their configs" },
+      { value: "agent-briefing", label: "Agent briefing", description: "Send agent types/capabilities info to LLM (Optional, if having issues)" },
+    ];
+
+    const selectList = new SelectList(items, 10, buildSelectListTheme(theme));
+    selectList.onSelect = async (item) => {
+      if (item.value === "agent-types") {
+        await showAgentTypes(ctx);
+      } else if (item.value === "agent-briefing") {
+        await handleAgentBriefing(ctx);
+      }
+    };
+    return new SettingsListWrapper(selectList, { title: "Debug", theme, onCancel: () => done(undefined) });
+  });
+}

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

@@ -0,0 +1,208 @@
+/**
+ * menu-model-settings.ts — Model settings menu concern.
+ *
+ * Uses SettingsList from @earendil-works/pi-tui via ctx.ui.custom.
+ * Model overrides use 2-step submenu: override mode → model selection.
+ * Cost display toggle removed (already in widget settings → usage stats).
+ *
+ * Exports:
+ *   - showModelSettingsMenu: model settings with global default, per-type overrides
+ */
+
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { SettingsList, SelectList, type SettingItem } from "@earendil-works/pi-tui";
+import { getAgentConfig, getAllTypes } from "../../agents/agent-types.js";
+import { CONFIG_AGENT_NON_MODEL_KEYS } from "../../config/types.js";
+import { buildSettingsListTheme, buildSelectListTheme, createDelegatingComponent } from "./helpers.js";
+import { createModelSelectSubmenu } from "./submenus/model-select.js";
+import { createConfirmSubmenu } from "./submenus/confirm.js";
+import { SettingsListWrapper } from "./wrappers/settings-list.js";
+import { getStore } from "../../shell.js";
+
+export async function showModelSettingsMenu(
+  ctx: ExtensionCommandContext,
+  modelOptions: string[],
+): Promise<void> {
+  // Build menu items from current store state.
+  const buildItems = (store: ReturnType<typeof getStore>, theme: any): SettingItem[] => {
+    const items: SettingItem[] = [];
+    
+    // Shared onSelect for model override submenus: applies session/permanent/clear
+    // mode to the given config key, with `label` used in notify messages.
+    const modelOverrideOnSelect = (
+      key: string,
+      label: string,
+    ): (mode: "session" | "permanent" | "clear", model: string | null) => void =>
+      (mode, model) => {
+        if (mode === "clear") {
+          store.mutate.agent.clearModelOverride(key);
+          store.mutate.session.clearOverride(key);
+          ctx.ui.notify(`${label} overrides cleared`, "info");
+          return;
+        }
+        const effective = model === "(inherits parent)" ? null : model;
+        if (mode === "session") {
+          if (effective === null) {
+            store.mutate.session.clearOverride(key);
+          } else {
+            store.mutate.session.setOverride(key, effective);
+          }
+        } else {
+          store.mutate.agent.setModelOverride(key, effective);
+        }
+        ctx.ui.notify(
+          effective === null
+            ? `${label} inherits parent model`
+            : `${label} model set to ${effective}`,
+          "info",
+        );
+      };
+
+    // Global default model
+    const sessionDefault = store.sessionDefaultModel;
+    const hasSessionGlobal = sessionDefault != null;
+    const globalDisplayValue = hasSessionGlobal
+      ? `${sessionDefault} [session]`
+      : store.agent.defaultModel
+        ? store.agent.defaultModel
+        : "(inherits parent)";
+
+    items.push({
+      id: "defaultModel",
+      label: "Global default model",
+      currentValue: globalDisplayValue,
+      submenu: createModelSelectSubmenu({
+        modelOptions,
+        showClear: false,
+        theme,
+        onSelect: modelOverrideOnSelect("default", "Global default"),
+      }),
+    });
+
+    // Per-type overrides
+    items.push({ id: "__sep__", label: " ", currentValue: "" });
+    items.push({ id: "__sep__", label: "── Per-type overrides ──", currentValue: "────────" });
+    const types = getAllTypes();
+    const typeEntries = types.map((typeName) => {
+      const cfg = getAgentConfig(typeName);
+      const sessionOverride = store.sessionModelOverride(typeName);
+      const configOverride = store.agentConfigSnapshot()[typeName];
+      const hasSession = sessionOverride != null;
+      const hasConfigOverride = configOverride != null && typeof configOverride === "string";
+      const effectiveModel = store.modelFor(typeName, "(inherits parent)", cfg);
+      return { typeName, cfg, sessionOverride, configOverride, hasSession, hasConfigOverride, effectiveModel };
+    });
+
+    const overridden = typeEntries.filter(e => e.hasSession || e.hasConfigOverride);
+    const nonOverridden = typeEntries.filter(e => !e.hasSession && !e.hasConfigOverride);
+
+    for (const { typeName, cfg, sessionOverride, configOverride, hasSession, effectiveModel } of overridden) {
+      const frontmatterHint = !hasSession && configOverride && cfg?.model ? `${cfg.model} → ` : "";
+      const displayModel = hasSession ? `${sessionOverride} [session]` : effectiveModel;
+      const hasPerm = !!configOverride;
+
+      items.push({
+        id: `type:${typeName}`,
+        label: typeName,
+        currentValue: `${frontmatterHint}${displayModel}`,
+        submenu: createModelSelectSubmenu({
+          modelOptions,
+          showClear: hasPerm,
+          theme,
+          onSelect: modelOverrideOnSelect(typeName, typeName),
+        }),
+      });
+    }
+
+    items.push({ id: "__sep__", label: "─────────────────────────", currentValue: "────────" });
+    // Override another type...
+    if (nonOverridden.length > 0) {
+      items.push({
+        id: "overrideType",
+        label: "Override another type...",
+        currentValue: "",
+        submenu: (_currentValue, subDone) => {
+          const typeNames = nonOverridden.map(e => ({ value: e.typeName, label: e.typeName }));
+          const typeList = new SelectList(typeNames, 10, buildSelectListTheme(theme));
+          const delegator = createDelegatingComponent(typeList);
+
+          typeList.onSelect = (item) => {
+            const entry = nonOverridden.find(e => e.typeName === item.value)!;
+            // Delegate to createModelSelectSubmenu for the 2-step model flow
+            const modelSubmenu = createModelSelectSubmenu({
+              modelOptions,
+              showClear: false,
+              theme,
+              onSelect: modelOverrideOnSelect(entry.typeName, entry.typeName),
+            });
+            delegator.setActive(modelSubmenu(entry.effectiveModel, subDone));
+          };
+          typeList.onCancel = () => subDone();
+
+          return delegator;
+        },
+      });
+    }
+
+    items.push({ id: "__sep__", label: " ", currentValue: "" });
+    // Clear session overrides
+    const hasSessionOverrides = store.sessionDefaultModel != null ||
+      getAllTypes().some(type => store.sessionModelOverride(type) != null);
+    if (hasSessionOverrides) {
+      items.push({
+        id: "clearSession",
+        label: "Clear session overrides",
+        currentValue: "",
+        submenu: createConfirmSubmenu({
+          message: "Clear all session overrides?",
+          theme,
+          onConfirm: () => {
+            store.mutate.session.clearAll();
+            ctx.ui.notify("Session overrides cleared", "info");
+          },
+        }),
+      });
+    }
+
+    // Clear all overrides
+    items.push({
+      id: "clearAll",
+      label: "Clear all overrides",
+      currentValue: "",
+      submenu: createConfirmSubmenu({
+        message: "Clear all model overrides?",
+        theme,
+        onConfirm: () => {
+          const agentConfig = store.agentConfigSnapshot();
+          const hasOverrides = Object.entries(agentConfig).some(
+            ([k, v]) => !CONFIG_AGENT_NON_MODEL_KEYS.includes(k) && v != null,
+          );
+          if (!hasOverrides && store.agent.defaultModel === null) {
+            ctx.ui.notify("No overrides to clear", "info");
+            return;
+          }
+          store.mutate.agent.clearAllModelOverrides();
+          ctx.ui.notify("All model overrides cleared", "info");
+        },
+      }),
+    });
+
+    return items;
+  };
+
+  let rebuild: ((items: any[]) => void) | undefined;
+
+  await ctx.ui.custom((_tui, theme, _kb, done) => {
+    const store = getStore();
+    const items = buildItems(store, theme);
+
+    
+    const settingsList = new SettingsList(items, 15, buildSettingsListTheme(theme), (_id, _v) => rebuild?.(buildItems(getStore(), theme)), () => done(undefined));
+    return new SettingsListWrapper(settingsList, {
+      title: "Model Settings",
+      theme,
+      onCancel: () => done(undefined),
+      onRebuild: (r) => { rebuild = r; },
+    });
+  });
+}