pi-advisor-flow 0.5.1 → 0.5.2

package/src/commands/settings-commands.ts

@@ -0,0 +1,80 @@
+import {
+  alwaysOnRef,
+  getAdvisorSettings,
+  getPersistedModelRefs,
+  setAlwaysOnRef,
+} from "../config/state.js";
+import { saveConfig } from "../config/storage.js";
+import { AdvisorSettingsSelector } from "../ui/settings-selector.js";
+import { loadCommandConfig } from "./activation-preparation.js";
+import { CONTEXT_PRESETS, EFFORT_LEVELS } from "./model-options.js";
+import { notify } from "./runtime.js";
+import { saveAdvisorSettings } from "./settings-persistence.js";
+import type { CommandRuntime } from "./types.js";
+
+export const registerSettingsCommands = (runtime: CommandRuntime) => {
+  runtime.pi.registerCommand("advisor-settings", {
+    description: "Configure Advisor settings",
+    handler: async (_args, ctx) => {
+      if (!(loadCommandConfig(ctx) && ctx.hasUI)) {
+        return;
+      }
+
+      const initial = getAdvisorSettings();
+      await ctx.ui.custom<void>(
+        (tui, theme, _keybindings, done) =>
+          new AdvisorSettingsSelector({
+            effortLevels: EFFORT_LEVELS,
+            initial,
+            onCancel: () => done(),
+            onChange: (settings) => {
+              try {
+                saveAdvisorSettings(ctx, settings);
+                runtime.updateAdvisorUsageStatus(ctx);
+              } catch (error) {
+                const message =
+                  error instanceof Error ? error.message : String(error);
+                ctx.ui.notify(
+                  `Could not save Advisor settings: ${message}`,
+                  "error"
+                );
+              }
+            },
+            presets: CONTEXT_PRESETS,
+            theme,
+            tui,
+          })
+      );
+    },
+  });
+
+  runtime.pi.registerCommand("advisor-off", {
+    description: "Disable on-demand Advisor calls; keep the current model",
+    handler: (_args, ctx) => {
+      runtime.pi.setActiveTools(
+        runtime.pi
+          .getActiveTools()
+          .filter(
+            (name) =>
+              name !== "ask_advisor" && name !== "record_advisor_outcome"
+          )
+      );
+      // Leaving alwaysOn set would silently reactivate the flow next session.
+      const wasAlwaysOn = alwaysOnRef;
+      if (wasAlwaysOn) {
+        const persisted = getPersistedModelRefs();
+        setAlwaysOnRef(false);
+        saveConfig(ctx, {
+          persistAdvisor: Boolean(persisted.advisor),
+          persistExecutor: Boolean(persisted.executor),
+        });
+      }
+      notify(
+        ctx,
+        `Advisor flow disabled. Current model unchanged.${wasAlwaysOn ? " Always on turned off." : ""}`,
+        "info"
+      );
+      return Promise.resolve();
+    },
+  });
+};

package/src/commands/settings-persistence.ts

@@ -0,0 +1,81 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  getPersistedModelRefs,
+  setAdvisorAutoLoopGateRef,
+  setAdvisorBlockOnBlockedRef,
+  setAdvisorCollapseResponsesRef,
+  setAdvisorCompletionGateRef,
+  setAdvisorCustomInvocationRef,
+  setAdvisorEffortRef,
+  setAdvisorFailureGateRef,
+  setAdvisorFailureModeRef,
+  setAdvisorGitContextMaxCharsRef,
+  setAdvisorGitContextRef,
+  setAdvisorHerdrIntegrationRef,
+  setAdvisorLoopThresholdRef,
+  setAdvisorMaxCallsPerSessionRef,
+  setAdvisorOutcomeLoggingRef,
+  setAdvisorPlanGateRef,
+  setAdvisorRedactSecretsRef,
+  setAdvisorScoutEnabledRef,
+  setAdvisorSessionSummaryRef,
+  setAdvisorToolPoliciesRef,
+  setAdvisorToolResultMaxBytesRef,
+  setAdvisorToolResultMaxLinesRef,
+  setAdvisorTrackedFileContentRef,
+  setAdvisorUntrackedContentRef,
+  setAlwaysOnRef,
+  setContextMaxCharsRef,
+  setShowUsageDetailsRef,
+  setShowUsageFooterRef,
+  setSimpleModeRef,
+} from "../config/state.js";
+import { saveConfig, saveGlobalOutcomeLogging } from "../config/storage.js";
+import type { AdvisorSettings } from "../ui/types.js";
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: one settings form maps every persisted control.
+export const applyAdvisorSettings = (settings: AdvisorSettings) => {
+  setAdvisorEffortRef(
+    settings.effort === "Default (Model Default)" ? undefined : settings.effort
+  );
+  setContextMaxCharsRef(settings.contextMaxChars);
+  setAdvisorPlanGateRef(settings.planGate);
+  setAdvisorFailureGateRef(settings.failureGate);
+  setAdvisorCompletionGateRef(settings.completionGate);
+  setAdvisorCollapseResponsesRef(settings.collapseResponses);
+  setAdvisorCustomInvocationRef(settings.customRule);
+  setAdvisorBlockOnBlockedRef(settings.blockOnBlocked ?? true);
+  setAdvisorAutoLoopGateRef(settings.autoLoopGate ?? true);
+  setAdvisorLoopThresholdRef(settings.loopThreshold ?? 3);
+  setAdvisorMaxCallsPerSessionRef(settings.maxCallsPerSession);
+  setAdvisorSessionSummaryRef(settings.sessionSummary ?? false);
+  setAdvisorScoutEnabledRef(settings.scoutEnabled ?? false);
+  setShowUsageDetailsRef(settings.showUsageDetails ?? true);
+  setShowUsageFooterRef(settings.showUsageFooter ?? false);
+  setSimpleModeRef(settings.simpleMode ?? false);
+  setAlwaysOnRef(settings.alwaysOn ?? false);
+  setAdvisorFailureModeRef(settings.failureMode ?? "block-session");
+  setAdvisorHerdrIntegrationRef(settings.herdrIntegration ?? true);
+  setAdvisorToolResultMaxLinesRef(settings.toolResultMaxLines ?? 2000);
+  setAdvisorToolResultMaxBytesRef(settings.toolResultMaxBytes ?? 50 * 1024);
+  setAdvisorRedactSecretsRef(settings.redactSecrets ?? false);
+  setAdvisorGitContextRef(settings.gitContext ?? "summary");
+  setAdvisorGitContextMaxCharsRef(settings.gitContextMaxChars ?? 20_000);
+  setAdvisorToolPoliciesRef(settings.toolPolicies ?? {});
+  setAdvisorTrackedFileContentRef(settings.trackedFileContent ?? false);
+  setAdvisorUntrackedContentRef(settings.untrackedContent ?? false);
+  setAdvisorOutcomeLoggingRef(settings.outcomeLogging ?? false);
+};
+
+export const saveAdvisorSettings = (
+  ctx: ExtensionContext,
+  settings: AdvisorSettings
+) => {
+  applyAdvisorSettings(settings);
+  const persisted = getPersistedModelRefs();
+  saveConfig(ctx, {
+    persistAdvisor: Boolean(persisted.advisor),
+    persistExecutor: Boolean(persisted.executor),
+  });
+  saveGlobalOutcomeLogging(settings.outcomeLogging ?? false);
+};

package/src/commands/types.ts

@@ -0,0 +1,78 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  Theme,
+} from "@earendil-works/pi-coding-agent";
+import type { GitContextLevel } from "../git.js";
+import type { ScoutLifecycleEvent } from "../scout.js";
+import type { AdvisorSessionState } from "../session-state.js";
+import type { ScoutStatusManager } from "../tools/scout-status.js";
+import type { ScoutToolDetails } from "../tools/types.js";
+
+export type ManualConsult = (
+  ctx: ExtensionContext,
+  question?: string,
+  signal?: AbortSignal,
+  onChunk?: (thinking: string, text: string) => void,
+  onScout?: (event: ScoutLifecycleEvent) => void,
+  gitContext?: GitContextLevel
+) => Promise<{
+  markdown: string;
+  thinkingText: string;
+  draftBytes?: number;
+  preferenceBytes?: number;
+  usage?: unknown;
+}>;
+
+export type ThinkingLevel = Parameters<ExtensionAPI["setThinkingLevel"]>[0];
+
+export type ManualAdvisorProgressPhase =
+  | "preparing"
+  | "active"
+  | "complete"
+  | "cancelled"
+  | "error";
+
+export interface ManualAdvisorProgressState {
+  phase: ManualAdvisorProgressPhase;
+  scout?: ScoutToolDetails;
+  text?: string;
+  thinking?: string;
+}
+
+export interface CommandDependencies {
+  consult?: ManualConsult;
+  sessionState?: AdvisorSessionState;
+  statusManager?: ScoutStatusManager;
+}
+
+export interface CommandRuntime {
+  readonly advisorSessionState: AdvisorSessionState;
+  flowEnabled: () => boolean;
+  readonly manualConsultations: Map<AbortController, symbol>;
+  readonly manualProgress: Map<string, ManualAdvisorProgressState>;
+  manualProgressSequence: number;
+  readonly manualProgressTimers: Map<
+    AbortController,
+    ReturnType<typeof setInterval>
+  >;
+  nextManualProgressId: () => string;
+  pendingExecutorModelRef: string | undefined;
+  readonly pi: ExtensionAPI;
+  reportManualBudgetExhausted: (ctx: ExtensionContext) => void;
+  readonly requestAdvisor: ManualConsult;
+  requestManualRender: (ctx: ExtensionContext) => void;
+  readonly scoutStatus: ScoutStatusManager;
+  setExecutorModel: (
+    model: Parameters<ExtensionAPI["setModel"]>[0]
+  ) => ReturnType<ExtensionAPI["setModel"]>;
+  suppressModelSelectionSync: boolean;
+  updateAdvisorUsageStatus: (ctx: ExtensionContext) => void;
+}
+
+export interface ManualAdvisorProgressView {
+  expanded: boolean;
+  question: string | undefined;
+  state: ManualAdvisorProgressState;
+  theme: Theme;
+}