@gotgenes/pi-subagents 6.4.0 → 6.6.0

package/src/settings.ts

@@ -16,16 +16,134 @@ export interface SubagentsSettings {
   graceTurns?: number;
 }
 
-/** Setter hooks used by applySettings to wire persisted values into in-memory state. */
-export interface SettingsAppliers {
-  setMaxConcurrent: (n: number) => void;
-  setDefaultMaxTurns: (n: number) => void;
-  setGraceTurns: (n: number) => void;
-}
 
 /** Emit callback — a subset of `pi.events.emit` to keep helpers testable. */
 export type SettingsEmit = (event: string, payload: unknown) => void;
 
+const DEFAULT_MAX_CONCURRENT = 4;
+const DEFAULT_GRACE_TURNS = 5;
+
+/**
+ * Owns all three in-memory settings values and their load/save/persist cycle.
+ * Replaces the scattered free-function + SettingsAppliers callback pattern.
+ */
+export class SettingsManager {
+  private _defaultMaxTurns: number | undefined = undefined;
+  private _graceTurns: number = DEFAULT_GRACE_TURNS;
+  private _maxConcurrent: number = DEFAULT_MAX_CONCURRENT;
+
+  private readonly emit: SettingsEmit;
+  private readonly cwd: string;
+  private readonly onMaxConcurrentChanged: (() => void) | undefined;
+
+  constructor(deps: { emit: SettingsEmit; cwd: string; onMaxConcurrentChanged?: () => void }) {
+    this.emit = deps.emit;
+    this.cwd = deps.cwd;
+    this.onMaxConcurrentChanged = deps.onMaxConcurrentChanged;
+  }
+
+  // ── defaultMaxTurns: 0 or undefined → unlimited (undefined); else max(1, n) ──
+
+  get defaultMaxTurns(): number | undefined {
+    return this._defaultMaxTurns;
+  }
+
+  set defaultMaxTurns(n: number | undefined) {
+    if (n == null || n === 0) {
+      this._defaultMaxTurns = undefined;
+    } else {
+      this._defaultMaxTurns = Math.max(1, n);
+    }
+  }
+
+  // ── graceTurns: minimum 1 ──
+
+  get graceTurns(): number {
+    return this._graceTurns;
+  }
+
+  set graceTurns(n: number) {
+    this._graceTurns = Math.max(1, n);
+  }
+
+  // ── maxConcurrent: minimum 1 ──
+
+  get maxConcurrent(): number {
+    return this._maxConcurrent;
+  }
+
+  set maxConcurrent(n: number) {
+    this._maxConcurrent = Math.max(1, n);
+  }
+
+  // ── Lifecycle methods ──
+
+  /**
+   * Load merged settings (global + project), apply to in-memory values,
+   * and emit the `subagents:settings_loaded` lifecycle event.
+   * Returns the raw loaded settings object.
+   */
+  load(): SubagentsSettings {
+    const settings = loadSettings(this.cwd);
+    if (typeof settings.maxConcurrent === "number") this.maxConcurrent = settings.maxConcurrent;
+    if (typeof settings.defaultMaxTurns === "number") this.defaultMaxTurns = settings.defaultMaxTurns;
+    if (typeof settings.graceTurns === "number") this.graceTurns = settings.graceTurns;
+    this.emit("subagents:settings_loaded", { settings });
+    return settings;
+  }
+
+  /**
+   * Snapshot current in-memory values for persistence.
+   * `defaultMaxTurns` uses 0 as the on-disk marker for unlimited (undefined).
+   */
+  snapshot(): { maxConcurrent: number; defaultMaxTurns: number; graceTurns: number } {
+    return {
+      maxConcurrent: this._maxConcurrent,
+      defaultMaxTurns: this._defaultMaxTurns ?? 0,
+      graceTurns: this._graceTurns,
+    };
+  }
+
+  /**
+   * Set maxConcurrent, notify interested parties, persist, and return the toast.
+   * Owns the full consequence chain so callers just say what they want.
+   */
+  applyMaxConcurrent(n: number): { message: string; level: "info" | "warning" } {
+    this.maxConcurrent = n; // setter normalizes: max(1, n)
+    this.onMaxConcurrentChanged?.();
+    return this.saveAndNotify(`Max concurrency set to ${this.maxConcurrent}`);
+  }
+
+  /**
+   * Set defaultMaxTurns, persist, and return the toast.
+   * Pass 0 for unlimited (maps to undefined internally).
+   */
+  applyDefaultMaxTurns(n: number): { message: string; level: "info" | "warning" } {
+    this.defaultMaxTurns = n === 0 ? undefined : n; // setter normalizes further
+    const label = this.defaultMaxTurns == null ? "unlimited" : String(this.defaultMaxTurns);
+    return this.saveAndNotify(`Default max turns set to ${label}`);
+  }
+
+  /**
+   * Set graceTurns, persist, and return the toast.
+   */
+  applyGraceTurns(n: number): { message: string; level: "info" | "warning" } {
+    this.graceTurns = n; // setter normalizes: max(1, n)
+    return this.saveAndNotify(`Grace turns set to ${this.graceTurns}`);
+  }
+
+  /**
+   * Persist the current snapshot, emit `subagents:settings_changed`,
+   * and return the toast the UI should display.
+   */
+  saveAndNotify(successMsg: string): { message: string; level: "info" | "warning" } {
+    const snap = this.snapshot();
+    const persisted = saveSettings(snap, this.cwd);
+    this.emit("subagents:settings_changed", { settings: snap, persisted });
+    return persistToastFor(successMsg, persisted);
+  }
+}
+
 // Sanity ceilings — prevent hand-edited configs from asking for values that
 // make no operational sense (e.g. 1e6 concurrent subagents). Permissive enough
 // that any realistic power-user setting passes through.
@@ -107,13 +225,6 @@ export function saveSettings(s: SubagentsSettings, cwd: string = process.cwd()):
   }
 }
 
-/** Apply persisted settings to the in-memory state via caller-supplied setters. */
-export function applySettings(s: SubagentsSettings, appliers: SettingsAppliers): void {
-  if (typeof s.maxConcurrent === "number") appliers.setMaxConcurrent(s.maxConcurrent);
-  if (typeof s.defaultMaxTurns === "number") appliers.setDefaultMaxTurns(s.defaultMaxTurns);
-  if (typeof s.graceTurns === "number") appliers.setGraceTurns(s.graceTurns);
-}
-
 /**
  * Format the user-facing toast for a settings mutation. Pure function —
  * routes the success/failure of `saveSettings` into the right message + level
@@ -127,36 +238,3 @@ export function persistToastFor(
     ? { message: successMsg, level: "info" }
     : { message: `${successMsg} (session only; failed to persist)`, level: "warning" };
 }
-
-/**
- * Load merged settings, apply them to in-memory state, and emit the
- * `subagents:settings_loaded` lifecycle event. Returns the loaded settings so
- * callers can log/inspect. Extension init wires this once.
- */
-export function applyAndEmitLoaded(
-  appliers: SettingsAppliers,
-  emit: SettingsEmit,
-  cwd: string = process.cwd(),
-): SubagentsSettings {
-  const settings = loadSettings(cwd);
-  applySettings(settings, appliers);
-  emit("subagents:settings_loaded", { settings });
-  return settings;
-}
-
-/**
- * Persist a settings snapshot, emit the `subagents:settings_changed` event
- * (regardless of persist outcome so listeners see the in-memory change), and
- * return the toast the UI should display. Event payload carries the `persisted`
- * flag so listeners can react to write failures.
- */
-export function saveAndEmitChanged(
-  snapshot: SubagentsSettings,
-  successMsg: string,
-  emit: SettingsEmit,
-  cwd: string = process.cwd(),
-): { message: string; level: "info" | "warning" } {
-  const persisted = saveSettings(snapshot, cwd);
-  emit("subagents:settings_changed", { settings: snapshot, persisted });
-  return persistToastFor(successMsg, persisted);
-}

package/src/tools/agent-tool.ts

@@ -112,8 +112,8 @@ export interface AgentToolDeps {
   typeListText: string;
   availableTypesText: string;
   agentDir: string;
-  /** Returns the runtime default max turns (undefined = unlimited). */
-  getDefaultMaxTurns: () => number | undefined;
+  /** Narrow settings accessor — only the default max turns is needed here. */
+  settings: { readonly defaultMaxTurns: number | undefined };
 }
 
 // ---- Factory ----
@@ -364,7 +364,7 @@ Guidelines:
           ? (model?.name ?? effectiveModelId).replace(/^Claude\s+/i, "").toLowerCase()
           : undefined;
       const effectiveMaxTurns = normalizeMaxTurns(
-        resolvedConfig.maxTurns ?? deps.getDefaultMaxTurns(),
+        resolvedConfig.maxTurns ?? deps.settings.defaultMaxTurns,
       );
       const agentInvocation: AgentInvocation = {
         modelName,

package/src/ui/agent-menu.ts

@@ -20,8 +20,16 @@ export interface AgentMenuManager {
   getRecord: (id: string) => AgentRecord | undefined;
   /** Used by generate wizard to spawn an agent that writes the .md file. */
   spawnAndWait: (ctx: ExtensionContext, type: string, prompt: string, opts: Omit<SpawnOptions, "isBackground">) => Promise<AgentRecord>;
-  getMaxConcurrent: () => number;
-  setMaxConcurrent: (n: number) => void;
+}
+
+/** Narrow settings interface required by the agent menu. */
+export interface AgentMenuSettings {
+  readonly maxConcurrent: number;
+  readonly defaultMaxTurns: number | undefined;
+  readonly graceTurns: number;
+  applyMaxConcurrent(n: number): { message: string; level: "info" | "warning" };
+  applyDefaultMaxTurns(n: number): { message: string; level: "info" | "warning" };
+  applyGraceTurns(n: number): { message: string; level: "info" | "warning" };
 }
 
 export interface AgentMenuDeps {
@@ -30,24 +38,11 @@ export interface AgentMenuDeps {
   agentActivity: Map<string, AgentActivity>;
   /** Resolve model label for a given agent type + registry. */
   getModelLabel: (type: string, registry?: ModelRegistry) => string;
-  /** Snapshot current settings for persistence. */
-  snapshotSettings: () => { maxConcurrent: number; defaultMaxTurns: number; graceTurns: number };
-  /** Save settings and return a notification result. */
-  saveSettings: (
-    settings: { maxConcurrent: number; defaultMaxTurns: number; graceTurns: number },
-    successMsg: string,
-  ) => { message: string; level: string };
+  /** Settings manager — owns in-memory values and persistence. */
+  settings: AgentMenuSettings;
   emitEvent: (name: string, data: unknown) => void;
   personalAgentsDir: string;
   projectAgentsDir: string;
-  /** Returns the runtime default max turns (undefined = unlimited). */
-  getDefaultMaxTurns: () => number | undefined;
-  /** Returns the runtime grace turns value. */
-  getGraceTurns: () => number;
-  /** Updates the runtime default max turns (undefined = unlimited). */
-  setDefaultMaxTurns: (n: number | undefined) => void;
-  /** Updates the runtime grace turns value (minimum 1). */
-  setGraceTurns: (n: number) => void;
 }
 
 // ---- Narrow UI context types ----
@@ -608,22 +603,22 @@ ${systemPrompt}
 
   async function showSettings(ctx: ExtensionContext) {
     const choice = await ctx.ui.select("Settings", [
-      `Max concurrency (current: ${deps.manager.getMaxConcurrent()})`,
-      `Default max turns (current: ${deps.getDefaultMaxTurns() ?? "unlimited"})`,
-      `Grace turns (current: ${deps.getGraceTurns()})`,
+      `Max concurrency (current: ${deps.settings.maxConcurrent})`,
+      `Default max turns (current: ${deps.settings.defaultMaxTurns ?? "unlimited"})`,
+      `Grace turns (current: ${deps.settings.graceTurns})`,
     ]);
     if (!choice) return;
 
     if (choice.startsWith("Max concurrency")) {
       const val = await ctx.ui.input(
         "Max concurrent background agents",
-        String(deps.manager.getMaxConcurrent()),
+        String(deps.settings.maxConcurrent),
       );
       if (val) {
         const n = parseInt(val, 10);
         if (n >= 1) {
-          deps.manager.setMaxConcurrent(n);
-          notifyApplied(ctx, `Max concurrency set to ${n}`);
+          const toast = deps.settings.applyMaxConcurrent(n);
+          ctx.ui.notify(toast.message, toast.level);
         } else {
           ctx.ui.notify("Must be a positive integer.", "warning");
         }
@@ -631,16 +626,13 @@ ${systemPrompt}
     } else if (choice.startsWith("Default max turns")) {
       const val = await ctx.ui.input(
         "Default max turns before wrap-up (0 = unlimited)",
-        String(deps.getDefaultMaxTurns() ?? 0),
+        String(deps.settings.defaultMaxTurns ?? 0),
       );
       if (val) {
         const n = parseInt(val, 10);
-        if (n === 0) {
-          deps.setDefaultMaxTurns(undefined);
-          notifyApplied(ctx, "Default max turns set to unlimited");
-        } else if (n >= 1) {
-          deps.setDefaultMaxTurns(n);
-          notifyApplied(ctx, `Default max turns set to ${n}`);
+        if (n >= 0) {
+          const toast = deps.settings.applyDefaultMaxTurns(n);
+          ctx.ui.notify(toast.message, toast.level);
         } else {
           ctx.ui.notify("Must be 0 (unlimited) or a positive integer.", "warning");
         }
@@ -648,13 +640,13 @@ ${systemPrompt}
     } else if (choice.startsWith("Grace turns")) {
       const val = await ctx.ui.input(
         "Grace turns after wrap-up steer",
-        String(deps.getGraceTurns()),
+        String(deps.settings.graceTurns),
       );
       if (val) {
         const n = parseInt(val, 10);
         if (n >= 1) {
-          deps.setGraceTurns(n);
-          notifyApplied(ctx, `Grace turns set to ${n}`);
+          const toast = deps.settings.applyGraceTurns(n);
+          ctx.ui.notify(toast.message, toast.level);
         } else {
           ctx.ui.notify("Must be a positive integer.", "warning");
         }
@@ -662,11 +654,6 @@ ${systemPrompt}
     }
   }
 
-  function notifyApplied(ctx: ExtensionContext, successMsg: string) {
-    const { message, level } = deps.saveSettings(deps.snapshotSettings(), successMsg);
-    ctx.ui.notify(message, level as "info" | "warning" | "error");
-  }
-
   // Return the handler function
   return async (ctx: ExtensionContext) => {
     await showAgentsMenu(ctx);