pi-extended-teams 2.1.16

package/extensions/ui/extensions-command.ts

@@ -0,0 +1,282 @@
+import { getSettingsListTheme } from "@mariozechner/pi-coding-agent";
+import {
+  Container,
+  Key,
+  matchesKey,
+  type SettingItem,
+  SettingsList,
+  Text,
+  truncateToWidth,
+} from "@mariozechner/pi-tui";
+import {
+  globalSettingsPath,
+  loadSettings,
+  readProjectExtensionAllowOverride,
+  replaceGlobalExtensionAllow,
+  type PiExtendedTeamsSettings,
+} from "../../src/utils/settings";
+import {
+  createSpawnResourcePlan,
+  EXTENSIONS_COMMAND_DESCRIPTION,
+  parentProjectTrustForSpawn,
+  type SpawnExtensionCandidate,
+  type SpawnResourcePlan,
+} from "../resources/spawn-resource-plan";
+
+const MODE_SETTING_ID = "__selection_mode__";
+
+interface ExtensionPickerResult {
+  mode: "default" | "explicit";
+  selectedIdentities: readonly string[];
+}
+
+export interface ExtensionsCommandOptions {
+  createResourcePlan?(
+    options: Parameters<typeof createSpawnResourcePlan>[0],
+  ): ReturnType<typeof createSpawnResourcePlan> | Promise<ReturnType<typeof createSpawnResourcePlan>>;
+  loadTeamsSettings?: typeof loadSettings;
+  saveAllow?: typeof replaceGlobalExtensionAllow;
+  readProjectExtensionAllowOverride?: typeof readProjectExtensionAllowOverride;
+  getGlobalSettingsPath?: typeof globalSettingsPath;
+}
+
+function provenanceLabel(extension: SpawnExtensionCandidate): string {
+  const sourceInfo = extension.sourceInfo;
+  return [sourceInfo.scope, sourceInfo.origin, sourceInfo.source].filter(Boolean).join(" · ");
+}
+
+function displayLabel(extension: SpawnExtensionCandidate): string {
+  const normalized = extension.path.replace(/\\/g, "/");
+  const base = normalized.split("/").pop() || normalized;
+  if (/^index\.(?:ts|js|mjs|cjs)$/.test(base)) {
+    return normalized.split("/").at(-2) || normalized;
+  }
+  return base;
+}
+
+function stateLabel(extension: SpawnExtensionCandidate): string {
+  switch (extension.state) {
+    case "selected": return "enabled";
+    case "available": return "disabled";
+    case "blocked": return "blocked";
+    case "self": return "internal";
+  }
+}
+
+function preservedConfiguredEntries(plan: SpawnResourcePlan): string[] {
+  const preservedCodes = new Set(["stale-selection", "blocked-selection"]);
+  return plan.diagnostics.flatMap((diagnostic) => {
+    return diagnostic.configuredEntry && preservedCodes.has(diagnostic.code)
+      ? [diagnostic.configuredEntry]
+      : [];
+  });
+}
+
+export function explicitAllowFromPicker(
+  plan: SpawnResourcePlan,
+  result: ExtensionPickerResult,
+): string[] | null {
+  if (result.mode === "default") return null;
+  const selected = new Set(result.selectedIdentities);
+  return Array.from(new Set([
+    ...plan.extensions
+      .filter((extension) => selected.has(extension.identity) && (extension.state === "selected" || extension.state === "available"))
+      .map((extension) => extension.identity),
+    ...preservedConfiguredEntries(plan),
+  ]));
+}
+
+export function formatExtensionsPlan(plan: SpawnResourcePlan): string {
+  const lines = [
+    "Agent extensions",
+    "Skills use normal Pi discovery and trust. pi-extended-teams is handled internally.",
+    "Visibility: Pi exposes sourceInfo for registered commands/tools; event-only extensions cannot be propagated.",
+    `Selection: ${plan.selectionMode === "default" ? "default (all observable loaded)" : "explicit"}`,
+    "",
+  ];
+  for (const extension of plan.extensions) {
+    lines.push(`- ${stateLabel(extension)} · ${displayLabel(extension)} · ${provenanceLabel(extension)}`);
+    lines.push(`  ${extension.path}`);
+  }
+  for (const diagnostic of plan.diagnostics) lines.push(`! ${diagnostic.message}`);
+  return lines.join("\n");
+}
+
+async function showExtensionsPicker(
+  ctx: any,
+  plan: SpawnResourcePlan,
+): Promise<ExtensionPickerResult | null> {
+  return ctx.ui.custom((tui: any, theme: any, _keybindings: any, done: (value: ExtensionPickerResult | null) => void) => {
+    let mode = plan.selectionMode;
+    const selectedIdentities = new Set(
+      plan.extensions.filter((extension) => extension.selected).map((extension) => extension.identity),
+    );
+    const candidateByItemId = new Map<string, SpawnExtensionCandidate>();
+    const itemIdByIdentity = new Map<string, string>();
+
+    const items: SettingItem[] = [{
+      id: MODE_SETTING_ID,
+      label: "Selection policy",
+      currentValue: mode,
+      values: ["default", "explicit"],
+      description: "default follows all observable loaded Pi extensions; explicit uses only saved choices",
+    }];
+    plan.extensions.forEach((extension, index) => {
+      const id = `extension:${index}`;
+      candidateByItemId.set(id, extension);
+      itemIdByIdentity.set(extension.identity, id);
+      const selectable = extension.state === "selected" || extension.state === "available";
+      items.push({
+        id,
+        label: displayLabel(extension),
+        currentValue: stateLabel(extension),
+        values: selectable ? ["enabled", "disabled"] : undefined,
+        description: `${provenanceLabel(extension)} · ${extension.path}`,
+      });
+    });
+    plan.diagnostics.forEach((diagnostic, index) => {
+      if (!diagnostic.configuredEntry) return;
+      items.push({
+        id: `diagnostic:${index}`,
+        label: diagnostic.configuredEntry,
+        currentValue: diagnostic.code === "stale-selection" ? "missing" : "unavailable",
+        description: diagnostic.message,
+      });
+    });
+
+    const container = new Container();
+    container.addChild(new Text([
+      theme.fg("accent", theme.bold("Agent extension selection")),
+      theme.fg("dim", "Skills use normal Pi discovery and trust. pi-extended-teams is handled internally."),
+      theme.fg("dim", `ctrl+s: save explicit choices · esc: cancel · ${globalSettingsPath()}`),
+      "",
+    ].join("\n"), 1, 0));
+
+    let settingsList: SettingsList;
+    const refreshValues = () => {
+      settingsList.updateValue(MODE_SETTING_ID, mode);
+      for (const extension of plan.extensions) {
+        const id = itemIdByIdentity.get(extension.identity);
+        if (!id || (extension.state !== "selected" && extension.state !== "available")) continue;
+        settingsList.updateValue(id, selectedIdentities.has(extension.identity) ? "enabled" : "disabled");
+      }
+    };
+    settingsList = new SettingsList(
+      items,
+      Math.min(items.length + 2, 18),
+      getSettingsListTheme(),
+      (id, newValue) => {
+        if (id === MODE_SETTING_ID) {
+          mode = newValue === "default" ? "default" : "explicit";
+          if (mode === "default") {
+            for (const extension of plan.extensions) {
+              if (extension.state !== "blocked" && extension.state !== "self") {
+                selectedIdentities.add(extension.identity);
+              }
+            }
+          }
+          refreshValues();
+          return;
+        }
+        const extension = candidateByItemId.get(id);
+        if (!extension) return;
+        mode = "explicit";
+        if (newValue === "enabled") selectedIdentities.add(extension.identity);
+        else selectedIdentities.delete(extension.identity);
+        refreshValues();
+      },
+      () => done(null),
+      { enableSearch: true },
+    );
+    container.addChild(settingsList);
+
+    return {
+      render(width: number) {
+        return container.render(width).map((line) => truncateToWidth(line, width));
+      },
+      invalidate() {
+        container.invalidate();
+      },
+      handleInput(data: string) {
+        if (matchesKey(data, Key.ctrl("s"))) {
+          done({ mode, selectedIdentities: [...selectedIdentities] });
+          return;
+        }
+        settingsList.handleInput(data);
+        tui.requestRender();
+      },
+    };
+  }, {
+    overlay: true,
+    overlayOptions: { width: "92%", maxHeight: "88%", anchor: "center" },
+  });
+}
+
+export function registerExtensionsCommand(pi: any, options: ExtensionsCommandOptions = {}): void {
+  const createResourcePlan = options.createResourcePlan ?? createSpawnResourcePlan;
+  const loadTeamsSettings = options.loadTeamsSettings ?? loadSettings;
+  const saveAllow = options.saveAllow ?? replaceGlobalExtensionAllow;
+  const readProjectOverride = options.readProjectExtensionAllowOverride ?? readProjectExtensionAllowOverride;
+  const getGlobalSettingsPath = options.getGlobalSettingsPath ?? globalSettingsPath;
+
+  const savePolicy = (allow: string[] | null, ctx: any, successMessage: string): void => {
+    const projectTrusted = parentProjectTrustForSpawn(ctx, ctx.cwd);
+    const projectOverride = projectTrusted ? readProjectOverride(ctx.cwd) : null;
+    saveAllow(allow);
+    if (projectOverride) {
+      ctx.ui.notify(
+        `Global spawned-agent extension policy was saved to ${getGlobalSettingsPath()}. The trusted project override at ${projectOverride.filePath} remains authoritative for spawned agents in this project.`,
+        "warning",
+      );
+      return;
+    }
+    ctx.ui.notify(successMessage, "info");
+  };
+
+  pi.registerCommand("agents-extensions", {
+    description: EXTENSIONS_COMMAND_DESCRIPTION,
+    handler: async (args: string, ctx: any) => {
+      try {
+        const action = args.trim().toLowerCase();
+        if (action === "default") {
+          savePolicy(null, ctx, "Spawned agents now follow all effective enabled Pi extensions.");
+          return;
+        }
+        if (action === "none") {
+          savePolicy([], ctx, "Spawned agents will load no external extensions. Skills remain enabled.");
+          return;
+        }
+        if (action && action !== "list") {
+          throw new Error("Usage: /agents-extensions [list|default|none]");
+        }
+
+        const projectTrusted = parentProjectTrustForSpawn(ctx, ctx.cwd);
+        const settings: PiExtendedTeamsSettings = loadTeamsSettings({
+          projectDir: projectTrusted ? ctx.cwd : undefined,
+        });
+        const plan = await createResourcePlan({
+          cwd: ctx.cwd,
+          projectTrusted,
+          settings,
+          pi,
+        });
+        if (action === "list" || ctx.mode !== "tui" || typeof ctx.ui.custom !== "function") {
+          ctx.ui.notify(formatExtensionsPlan(plan), "info");
+          return;
+        }
+
+        const result = await showExtensionsPicker(ctx, plan);
+        if (!result) return;
+        savePolicy(
+          explicitAllowFromPicker(plan, result),
+          ctx,
+          result.mode === "default"
+            ? "Spawned-agent extensions reset to default."
+            : "Spawned-agent extension choices saved.",
+        );
+      } catch (error) {
+        ctx.ui.notify(error instanceof Error ? error.message : String(error), "warning");
+      }
+    },
+  });
+}

package/extensions/ui/favorite-models-command.test.ts

@@ -0,0 +1,280 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { registerFavoriteModelsCommand } from "./favorite-models-command.js";
+import { globalSettingsPath } from "../../src/utils/settings";
+
+let homeDir: string;
+
+function setupCommand() {
+  const commands = new Map<string, any>();
+  const pi = { registerCommand: vi.fn((name: string, command: any) => commands.set(name, command)) };
+  registerFavoriteModelsCommand(pi);
+  const ctx = {
+    modelRegistry: {
+      getAvailable: vi.fn(async (): Promise<any[]> => [{ provider: "provider", id: "model", reasoning: true }]),
+    },
+    ui: { notify: vi.fn() },
+  };
+  return { commands, ctx, pi };
+}
+
+function testTheme() {
+  return {
+    fg: (_name: string, value: string) => value,
+    bold: (value: string) => value,
+  };
+}
+
+beforeEach(() => {
+  homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "pet-favorite-models-"));
+  vi.spyOn(os, "homedir").mockReturnValue(homeDir);
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  fs.rmSync(homeDir, { recursive: true, force: true });
+});
+
+describe("/agents-favorite-models", () => {
+  it("registers and displays empty slots", async () => {
+    const { commands, ctx } = setupCommand();
+
+    await commands.get("agents-favorite-models").handler("", ctx);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("read-collect: (empty)"), "info");
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("write-critical: (empty)"), "info");
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Saved in:"), "info");
+  });
+
+  it("opens a single-screen picker with scoped available models and saves a slot", async () => {
+    const { commands } = setupCommand();
+    const notify = vi.fn();
+    const requestRender = vi.fn();
+    const custom = vi.fn(async (factory: any) => {
+      let doneValue: "saved" | "cancelled" | undefined;
+      const component = factory({ requestRender, terminal: { rows: 30 } }, testTheme(), {}, (value: "saved" | "cancelled") => {
+        doneValue = value;
+      });
+
+      expect(component.render(120).join("\n")).toContain("provider/model");
+      component.handleInput("l"); // focus scoped models
+      component.handleInput("\x1b[B"); // select first scoped model for read-collect
+      component.handleInput("\r"); // save
+      return doneValue;
+    });
+    const ctx = {
+      mode: "tui",
+      modelRegistry: {
+        getAvailable: vi.fn(async () => [{ provider: "provider", id: "model", reasoning: true }]),
+      },
+      ui: { notify, custom },
+    };
+
+    await commands.get("agents-favorite-models").handler("", ctx);
+
+    const raw = JSON.parse(fs.readFileSync(globalSettingsPath(homeDir), "utf-8"));
+    expect(raw.favoriteModels["read-collect"]).toEqual({ model: "provider/model", thinking: "high" });
+    expect(custom).toHaveBeenCalled();
+    expect(notify).toHaveBeenCalledWith("Agent favorite models saved.", "info");
+  });
+
+  it("applies the calibrated thinking default for all eight canonical tiers", async () => {
+    const { commands } = setupCommand();
+    const custom = vi.fn(async (factory: any) => {
+      let doneValue: "saved" | "cancelled" | undefined;
+      const component = factory(
+        { requestRender: vi.fn(), terminal: { rows: 30 } },
+        testTheme(),
+        {},
+        (value: "saved" | "cancelled") => { doneValue = value; },
+      );
+
+      component.handleInput("l");
+      for (let index = 0; index < 8; index += 1) {
+        component.handleInput("\x1b[B");
+        if (index < 7) {
+          component.handleInput("h");
+          component.handleInput("\x1b[B");
+          component.handleInput("l");
+        }
+      }
+      component.handleInput("\r");
+      return doneValue;
+    });
+    const ctx = {
+      mode: "tui",
+      modelRegistry: {
+        getAvailable: vi.fn(async () => [{
+          provider: "provider",
+          id: "model",
+          reasoning: true,
+          thinkingLevelMap: { xhigh: "xhigh", max: "max" },
+        }]),
+      },
+      ui: { notify: vi.fn(), custom },
+    };
+
+    await commands.get("agents-favorite-models").handler("", ctx);
+
+    const raw = JSON.parse(fs.readFileSync(globalSettingsPath(homeDir), "utf-8"));
+    expect(raw.favoriteModels).toEqual({
+      "read-collect": { model: "provider/model", thinking: "high" },
+      "read-review": { model: "provider/model", thinking: "xhigh" },
+      "read-analyze": { model: "provider/model", thinking: "medium" },
+      "read-critical": { model: "provider/model", thinking: "xhigh" },
+      "write-patch": { model: "provider/model", thinking: "max" },
+      "write-feature": { model: "provider/model", thinking: "medium" },
+      "write-system": { model: "provider/model", thinking: "high" },
+      "write-critical": { model: "provider/model", thinking: "max" },
+    });
+  });
+
+  it("shows max only when the selected Pi model advertises it", async () => {
+    const { commands } = setupCommand();
+    const custom = vi.fn(async (factory: any) => {
+      const component = factory(
+        { requestRender: vi.fn(), terminal: { rows: 30 } },
+        testTheme(),
+        {},
+        vi.fn(),
+      );
+
+      component.handleInput("l");
+      component.handleInput("\x1b[B");
+      component.handleInput("l");
+      const rendered = component.render(120).join("\n");
+      expect(rendered).toContain("  max");
+      expect(rendered).not.toContain("  xhigh");
+      return "cancelled";
+    });
+    const ctx = {
+      mode: "tui",
+      modelRegistry: {
+        getAvailable: vi.fn(async () => [{
+          provider: "provider",
+          id: "max-model",
+          reasoning: true,
+          thinkingLevelMap: { max: "max", xhigh: null },
+        }]),
+      },
+      ui: { notify: vi.fn(), custom },
+    };
+
+    await commands.get("agents-favorite-models").handler("", ctx);
+  });
+
+  it("hides opt-in levels that the selected Pi model does not advertise", async () => {
+    const { commands } = setupCommand();
+    const custom = vi.fn(async (factory: any) => {
+      const component = factory(
+        { requestRender: vi.fn(), terminal: { rows: 30 } },
+        testTheme(),
+        {},
+        vi.fn(),
+      );
+
+      component.handleInput("l");
+      component.handleInput("\x1b[B");
+      component.handleInput("l");
+      const rendered = component.render(120).join("\n");
+      expect(rendered).not.toContain("  max");
+      expect(rendered).not.toContain("  xhigh");
+      return "cancelled";
+    });
+    const ctx = {
+      mode: "tui",
+      modelRegistry: {
+        getAvailable: vi.fn(async () => [{ provider: "provider", id: "standard-model", reasoning: true }]),
+      },
+      ui: { notify: vi.fn(), custom },
+    };
+
+    await commands.get("agents-favorite-models").handler("", ctx);
+  });
+
+  it("does not save a thinking-only empty slot from the picker", async () => {
+    const { commands } = setupCommand();
+    const notify = vi.fn();
+    const custom = vi.fn(async (factory: any) => {
+      let doneValue: "saved" | "cancelled" | undefined;
+      const component = factory({ requestRender: vi.fn(), terminal: { rows: 30 } }, testTheme(), {}, (value: "saved" | "cancelled") => {
+        doneValue = value;
+      });
+
+      component.handleInput("l");
+      component.handleInput("l"); // focus thinking with no model selected
+      component.handleInput("\x1b[B");
+      expect(component.render(120).join("\n")).toContain("Pick a scoped model for read-collect before choosing thinking.");
+      component.handleInput("\r");
+      return doneValue;
+    });
+    const ctx = {
+      mode: "tui",
+      modelRegistry: {
+        getAvailable: vi.fn(async () => [{ provider: "provider", id: "model", reasoning: true }]),
+      },
+      ui: { notify, custom },
+    };
+
+    await commands.get("agents-favorite-models").handler("", ctx);
+
+    const raw = JSON.parse(fs.readFileSync(globalSettingsPath(homeDir), "utf-8"));
+    expect(raw.favoriteModels).toEqual({});
+  });
+
+  it("sets and clears canonical tiers while accepting legacy CLI aliases", async () => {
+    const { commands, ctx } = setupCommand();
+    const command = commands.get("agents-favorite-models");
+
+    await command.handler("set reading-fast provider/model high", ctx);
+
+    let raw = JSON.parse(fs.readFileSync(globalSettingsPath(homeDir), "utf-8"));
+    expect(raw.favoriteModels["read-collect"]).toEqual({ model: "provider/model", thinking: "high" });
+    expect(raw.favoriteModels).not.toHaveProperty("reading-fast");
+    expect(ctx.ui.notify).toHaveBeenLastCalledWith("Set read-collect to provider/model · high.", "info");
+
+    await command.handler("clear reading-fast", ctx);
+
+    raw = JSON.parse(fs.readFileSync(globalSettingsPath(homeDir), "utf-8"));
+    expect(raw.favoriteModels).not.toHaveProperty("read-collect");
+    expect(ctx.ui.notify).toHaveBeenLastCalledWith("Cleared read-collect.", "info");
+  });
+
+  it("accepts max only for a Pi model that advertises it", async () => {
+    const { commands, ctx } = setupCommand();
+    ctx.modelRegistry.getAvailable.mockResolvedValue([{
+      provider: "provider",
+      id: "max-model",
+      reasoning: true,
+      thinkingLevelMap: { max: "max" },
+    }]);
+
+    await commands.get("agents-favorite-models").handler("set read-critical provider/max-model max", ctx);
+
+    const raw = JSON.parse(fs.readFileSync(globalSettingsPath(homeDir), "utf-8"));
+    expect(raw.favoriteModels["read-critical"]).toEqual({ model: "provider/max-model", thinking: "max" });
+  });
+
+  it("rejects max when the Pi model does not advertise it", async () => {
+    const { commands, ctx } = setupCommand();
+
+    await commands.get("agents-favorite-models").handler("set read-critical provider/model max", ctx);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith(
+      expect.stringContaining('Thinking level "max" is not available for provider/model'),
+      "warning",
+    );
+    expect(fs.existsSync(globalSettingsPath(homeDir))).toBe(false);
+  });
+
+  it("warns for invalid input without writing settings", async () => {
+    const { commands, ctx } = setupCommand();
+
+    await commands.get("agents-favorite-models").handler("set bad-slot provider/model low", ctx);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Unknown slot"), "warning");
+    expect(fs.existsSync(globalSettingsPath(homeDir))).toBe(false);
+  });
+});