@sherif-fanous/pi-presets-plus 0.1.0

package/src/activation/clear.ts

@@ -0,0 +1,434 @@
+/**
+ * Active-preset clear flow.
+ *
+ * Owns restoring pi state from the baseline overlay (with user-override
+ * protection) and rendering a user-visible summary; it does NOT own apply,
+ * picker UI, or status formatting beyond its own summary.
+ */
+import type { ActivePresetState, ThinkingLevel } from "../types.js";
+import {
+  CLEAR_DIALOG_TITLE,
+  MODEL_LABEL,
+  THINKING_LABEL,
+  TOOLS_LABEL,
+} from "../ui/labels.js";
+import { updateStatus } from "../ui/status.js";
+import { clearActive, getActive } from "./active-state.js";
+import { withSelfTriggeredModelSet } from "./apply.js";
+import { sameSet } from "./same-set.js";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  Theme,
+} from "@mariozechner/pi-coding-agent";
+
+export interface ClearDecision {
+  readonly parts: readonly ClearPart[];
+  readonly writes: ClearWrites;
+}
+
+export interface ClearPart {
+  readonly action: ClearAction;
+  /** Tools that were dropped because they no longer exist (restored-partial only). */
+  readonly dropped?: readonly string[];
+  readonly field: ClearField;
+  /**
+   * The value to render after the field label.
+   *
+   * - For `restored` / `already-baseline` / `restored-partial`: the baseline
+   *   value (which is what the row reports as the post-clear state).
+   * - For `user-override` / `not-owned` / `baseline-null` / `unknown`: the
+   *   user's *current* value (which the clear left untouched).
+   * - For `restore-failed`: the baseline value we tried (and failed) to
+   *   reach; the renderer wraps it as "could not switch back to …".
+   */
+  readonly value: string;
+}
+
+export interface ClearSnapshot {
+  readonly active: ActivePresetState;
+  readonly allTools: readonly string[];
+  readonly currentModel: { provider: string; id: string } | null;
+  readonly currentThinking: ThinkingLevel;
+  readonly currentTools: readonly string[];
+}
+
+export interface ClearWrites {
+  readonly model?: { provider: string; id: string };
+  readonly thinkingLevel?: ThinkingLevel;
+  readonly tools?: readonly string[];
+}
+
+export type ClearAction =
+  | "already-baseline"
+  | "baseline-null"
+  | "not-owned"
+  | "restore-failed"
+  | "restored"
+  | "restored-partial"
+  | "unknown"
+  | "user-override";
+
+export type ClearField = "model" | "thinking" | "tools";
+
+interface Styler {
+  bold(text: string): string;
+  fg(color: Parameters<Theme["fg"]>[0], text: string): string;
+}
+
+const FIELD_LABELS: Record<ClearField, string> = {
+  model: MODEL_LABEL,
+  thinking: THINKING_LABEL,
+  tools: TOOLS_LABEL,
+};
+
+const IDENTITY_STYLER: Styler = {
+  bold: (text) => text,
+  fg: (_color, text) => text,
+};
+
+export interface ClearResult {
+  readonly name: string;
+  readonly parts: readonly ClearPart[];
+}
+
+/**
+ * Choose the plain-English lead sentence that sits under the title.
+ *
+ * The sentence describes the overall disposition so the per-row values
+ * underneath can stay short. Decision priority (most specific first):
+ *
+ *   1. Every field is `unknown` (priorUnknown branch) — no baseline saved.
+ *   2. Any field failed to restore — surface the problem in the lead.
+ *   3. Every field already matched baseline — nothing was actually written.
+ *   4. Every field is restore-like (restored / restored-partial /
+ *      already-baseline) — the happy path; mention unavailable tools if any.
+ *   5. Every field was kept (user-override / not-owned / baseline-null) —
+ *      preset turned off but no baseline values were applicable.
+ *   6. Otherwise it's a mixed result.
+ */
+export function chooseClearLead(parts: readonly ClearPart[]): string {
+  if (parts.every((part) => part.action === "unknown")) {
+    return "No saved baseline. Current settings were left as-is.";
+  }
+
+  if (parts.some((part) => part.action === "restore-failed")) {
+    return "Tried to restore your previous settings but ran into a problem.";
+  }
+
+  if (parts.every((part) => part.action === "already-baseline")) {
+    return "Your settings already matched the saved baseline.";
+  }
+
+  if (parts.every((part) => isRestoreLike(part.action))) {
+    return parts.some((part) => part.action === "restored-partial")
+      ? "Restored your previous settings. Some tools are no longer available."
+      : "Restored your previous settings.";
+  }
+
+  if (parts.every((part) => isKeptLike(part.action))) {
+    return "Kept all your manual changes. Nothing to restore.";
+  }
+
+  return "Restored some settings. Kept your manual changes for others.";
+}
+
+export async function clear(
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<void> {
+  const result = await clearReturning(ctx, pi);
+
+  ctx.ui.notify(
+    result
+      ? renderClearSummary(result.name, result.parts, ctx.ui.theme)
+      : "No preset is active.",
+    "info",
+  );
+}
+
+export async function clearReturning(
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<ClearResult | undefined> {
+  const active = getActive();
+
+  if (!active) return undefined;
+
+  const currentModel = ctx.model
+    ? { provider: ctx.model.provider, id: ctx.model.id }
+    : null;
+  const decision = decideClear({
+    active,
+    allTools: pi.getAllTools().map((tool) => tool.name),
+    currentModel,
+    currentThinking: pi.getThinkingLevel(),
+    currentTools: pi.getActiveTools(),
+  });
+  const finalParts = await executeClear(decision, ctx, pi);
+
+  clearActive();
+  pi.appendEntry("presets-plus:active", { name: null });
+  updateStatus(ctx, getActive(), () => undefined);
+
+  return { name: active.name, parts: finalParts };
+}
+
+export function decideClear(snapshot: ClearSnapshot): ClearDecision {
+  const { active } = snapshot;
+  const currentModelDisplay = formatModel(snapshot.currentModel);
+  const currentToolsDisplay = formatTools(snapshot.currentTools);
+
+  if (active.restore.kind === "unknown") {
+    return {
+      parts: [
+        { action: "unknown", field: "model", value: currentModelDisplay },
+        {
+          action: "unknown",
+          field: "thinking",
+          value: snapshot.currentThinking,
+        },
+        { action: "unknown", field: "tools", value: currentToolsDisplay },
+      ],
+      writes: {},
+    };
+  }
+
+  const parts: ClearPart[] = [];
+  const writes: {
+    -readonly [K in keyof ClearWrites]: ClearWrites[K];
+  } = {};
+  const { baseline, lastApplied, owned } = active.restore;
+
+  if (sameModel(snapshot.currentModel, baseline.model)) {
+    parts.push({
+      action: "already-baseline",
+      field: "model",
+      value: formatModel(baseline.model),
+    });
+  } else if (sameModel(snapshot.currentModel, lastApplied.model)) {
+    if (baseline.model) {
+      writes.model = baseline.model;
+      parts.push({
+        action: "restored",
+        field: "model",
+        value: formatModel(baseline.model),
+      });
+    } else {
+      parts.push({
+        action: "baseline-null",
+        field: "model",
+        value: currentModelDisplay,
+      });
+    }
+  } else {
+    parts.push({
+      action: "user-override",
+      field: "model",
+      value: currentModelDisplay,
+    });
+  }
+
+  if (snapshot.currentThinking === baseline.thinkingLevel) {
+    parts.push({
+      action: "already-baseline",
+      field: "thinking",
+      value: baseline.thinkingLevel,
+    });
+  } else if (snapshot.currentThinking === lastApplied.thinkingLevel) {
+    writes.thinkingLevel = baseline.thinkingLevel;
+    parts.push({
+      action: "restored",
+      field: "thinking",
+      value: baseline.thinkingLevel,
+    });
+  } else {
+    parts.push({
+      action: "user-override",
+      field: "thinking",
+      value: snapshot.currentThinking,
+    });
+  }
+
+  if (!owned.tools) {
+    parts.push({
+      action: "not-owned",
+      field: "tools",
+      value: currentToolsDisplay,
+    });
+  } else {
+    const lastAppliedTools = lastApplied.tools ?? [];
+
+    if (sameSet(snapshot.currentTools, baseline.tools)) {
+      parts.push({
+        action: "already-baseline",
+        field: "tools",
+        value: formatTools(baseline.tools),
+      });
+    } else if (sameSet(snapshot.currentTools, lastAppliedTools)) {
+      const available = new Set(snapshot.allTools);
+      const filtered = baseline.tools.filter((toolName) =>
+        available.has(toolName),
+      );
+      const dropped = baseline.tools.filter(
+        (toolName) => !available.has(toolName),
+      );
+
+      writes.tools = filtered;
+      parts.push({
+        action: dropped.length > 0 ? "restored-partial" : "restored",
+        dropped: dropped.length > 0 ? dropped : undefined,
+        field: "tools",
+        value: formatTools(filtered),
+      });
+    } else {
+      parts.push({
+        action: "user-override",
+        field: "tools",
+        value: currentToolsDisplay,
+      });
+    }
+  }
+
+  return { parts, writes };
+}
+
+export function renderClearSummary(
+  name: string,
+  parts: readonly ClearPart[],
+  styler: Pick<Theme, "bold" | "fg"> = IDENTITY_STYLER,
+): string {
+  const safeStyler = normalizeStyler(styler);
+  const labels = parts.map((part) => `${FIELD_LABELS[part.field]}:`);
+  const labelWidth = Math.max(...labels.map((label) => label.length));
+  const title = safeStyler.bold(
+    safeStyler.fg("accent", `${CLEAR_DIALOG_TITLE}: ${name}`),
+  );
+  const lead = chooseClearLead(parts);
+  const rows = parts.map((part) => {
+    const label = `${FIELD_LABELS[part.field]}:`;
+    const padding = " ".repeat(labelWidth - label.length);
+
+    return `  ${safeStyler.fg("muted", label)}${padding} ${formatRowValue(part)}`;
+  });
+
+  return [title, lead, ...rows].join("\n");
+}
+
+async function executeClear(
+  decision: ClearDecision,
+  ctx: Pick<ExtensionCommandContext, "modelRegistry">,
+  pi: Pick<ExtensionAPI, "setActiveTools" | "setModel" | "setThinkingLevel">,
+): Promise<ClearPart[]> {
+  const parts = decision.parts.map((part) => ({ ...part }));
+
+  if (decision.writes.model) {
+    const target = decision.writes.model;
+    const model = ctx.modelRegistry.find(target.provider, target.id);
+    const ok = model
+      ? await withSelfTriggeredModelSet(() => pi.setModel(model))
+      : false;
+
+    if (!ok) {
+      const index = parts.findIndex((part) => part.field === "model");
+
+      if (index >= 0) {
+        parts[index] = {
+          action: "restore-failed",
+          field: "model",
+          value: `${target.provider}/${target.id}`,
+        };
+      }
+    }
+  }
+
+  if (decision.writes.thinkingLevel !== undefined) {
+    pi.setThinkingLevel(decision.writes.thinkingLevel);
+  }
+
+  if (decision.writes.tools !== undefined) {
+    pi.setActiveTools([...decision.writes.tools]);
+  }
+
+  return parts;
+}
+
+function formatModel(model: { provider: string; id: string } | null): string {
+  return model ? `${model.provider}/${model.id}` : "none";
+}
+
+/**
+ * Render the post-colon body for a single field row.
+ *
+ * The vocabulary intentionally parallels `formatStatus` so a user reading
+ * `/presets status` and then `/presets clear <name>` sees the same phrases
+ * for manual overrides / "not managed by …" /
+ * "no baseline saved for this field". Restored / already-baseline rows
+ * stay bare — the lead sentence above the rows already explains the
+ * disposition.
+ */
+function formatRowValue(part: ClearPart): string {
+  switch (part.action) {
+    case "already-baseline":
+    case "restored":
+      return part.value;
+
+    case "baseline-null":
+    case "unknown":
+      return `${part.value} (No baseline saved for this field)`;
+
+    case "not-owned":
+      return `${part.value} (Not managed by cleared preset)`;
+
+    case "restore-failed":
+      return `Could not switch back to ${part.value}.`;
+
+    case "restored-partial":
+      return part.dropped && part.dropped.length > 0
+        ? `${part.value} (Unavailable: ${part.dropped.join(", ")})`
+        : part.value;
+
+    case "user-override":
+      return `${part.value} (Left as-is — you changed it after activation)`;
+  }
+}
+
+function formatTools(tools: readonly string[]): string {
+  return tools.length > 0 ? tools.join(", ") : "none";
+}
+
+function isKeptLike(action: ClearAction): boolean {
+  return (
+    action === "user-override" ||
+    action === "not-owned" ||
+    action === "baseline-null"
+  );
+}
+
+function isRestoreLike(action: ClearAction): boolean {
+  return (
+    action === "restored" ||
+    action === "restored-partial" ||
+    action === "already-baseline"
+  );
+}
+
+function normalizeStyler(styler: Pick<Theme, "bold" | "fg">): Styler {
+  return {
+    bold: (text) =>
+      typeof styler.bold === "function"
+        ? styler.bold(text)
+        : IDENTITY_STYLER.bold(text),
+    fg: (color, text) =>
+      typeof styler.fg === "function"
+        ? styler.fg(color, text)
+        : IDENTITY_STYLER.fg(color, text),
+  };
+}
+
+function sameModel(
+  left: { provider: string; id: string } | null,
+  right: { provider: string; id: string } | null,
+): boolean {
+  return left?.provider === right?.provider && left?.id === right?.id;
+}

package/src/activation/dirty.ts

@@ -0,0 +1,69 @@
+/**
+ * Dirty-flag transitions for the active preset attachment.
+ *
+ * Owns flipping the in-memory dirty flag and refreshing the status badge;
+ * it does NOT decide whether drift exists, notify the user, or read the
+ * on-disk preset files. Status refresh uses a synthetic preset built from
+ * the active state's cached `declared` snapshot, so the helpers stay
+ * in-memory only and never reopen the preset JSON files.
+ */
+import type { ActivePresetState, LoadedPreset } from "../types.js";
+import { updateStatus } from "../ui/status.js";
+import { getActive, setActive } from "./active-state.js";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+/** Minimal context surface needed to refresh status after dirty changes. */
+type DirtyContext = Pick<ExtensionContext, "ui">;
+
+/** Mark the active preset clean, preserving its restore discriminator. */
+export async function markClean(ctx: DirtyContext): Promise<void> {
+  const active = getActive();
+
+  if (!active?.dirty) return;
+
+  setActive({ ...active, dirty: false });
+  refreshStatus(ctx, getActive());
+
+  await Promise.resolve();
+}
+
+/** Mark the active preset dirty, preserving its restore discriminator. */
+export async function markDirty(ctx: DirtyContext): Promise<void> {
+  const active = getActive();
+
+  if (!active || active.dirty) return;
+
+  setActive({ ...active, dirty: true });
+  refreshStatus(ctx, getActive());
+
+  await Promise.resolve();
+}
+
+function refreshStatus(
+  ctx: DirtyContext,
+  active: ActivePresetState | undefined,
+): void {
+  // Synthesize a `LoadedPreset` from the active state so `updateStatus`
+  // can render `Preset: <name>` without re-reading the preset JSON files.
+  // The badge only needs `name` + `scope`; everything else is filler.
+  const synthetic: LoadedPreset | undefined = active
+    ? {
+        model: active.declared.model,
+        name: active.name,
+        provider: active.declared.provider,
+        scope: active.scope,
+        ...(active.declared.thinkingLevel !== undefined
+          ? { thinkingLevel: active.declared.thinkingLevel }
+          : {}),
+        ...(active.declared.tools !== undefined
+          ? { tools: [...active.declared.tools] }
+          : {}),
+      }
+    : undefined;
+
+  updateStatus(ctx, active, (name, scope) =>
+    synthetic && synthetic.name === name && synthetic.scope === scope
+      ? synthetic
+      : undefined,
+  );
+}

package/src/activation/drift-handlers.ts

@@ -0,0 +1,71 @@
+/**
+ * Event-handler logic for active-preset drift tracking.
+ *
+ * Owns translating Pi model/thinking/turn events into dirty-state updates;
+ * it does NOT register handlers with Pi, render picker/status UI directly,
+ * or read the on-disk preset files. Drift detection compares against the
+ * `declared` snapshot cached on `ActivePresetState` at apply / restore time
+ * so per-turn handlers stay in-memory only.
+ */
+import { getActive } from "./active-state.js";
+import { isSelfTriggeredModelSet } from "./apply.js";
+import { markClean, markDirty } from "./dirty.js";
+import { detectDriftReasons } from "./drift.js";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+
+/** Minimal model_select event surface needed for drift handling. */
+interface ModelSelectLikeEvent {
+  model: { id: string; provider: string };
+  source: "cycle" | "restore" | "set";
+}
+
+/** Minimal context surface needed for drift comparison and status refresh. */
+type DriftHandlerContext = Pick<
+  ExtensionContext,
+  "model" | "modelRegistry" | "ui"
+>;
+
+/** Minimal Pi surface needed for full-state drift sync. */
+type DriftHandlerPi = Pick<ExtensionAPI, "getActiveTools" | "getThinkingLevel">;
+
+/**
+ * Handle `model_select` by re-evaluating drift against the cached snapshot.
+ *
+ * The model-match branch deliberately delegates to a full drift recheck
+ * (instead of unconditionally marking clean) so that re-selecting the
+ * preset's model while thinking or tools are still drifted does not produce
+ * a stale-clean badge until the next `turn_start` runs.
+ */
+export async function handleModelSelectDrift(
+  event: ModelSelectLikeEvent,
+  ctx: DriftHandlerContext,
+  pi: DriftHandlerPi,
+): Promise<void> {
+  if (isSelfTriggeredModelSet()) return;
+  if (event.source === "restore") return;
+
+  await syncDirtyFromCurrentState(ctx, pi);
+}
+
+/** Recompute all drift reasons and update the dirty flag if needed. */
+export async function syncDirtyFromCurrentState(
+  ctx: DriftHandlerContext,
+  pi: DriftHandlerPi,
+): Promise<void> {
+  const active = getActive();
+
+  if (!active) return;
+
+  const reasons = detectDriftReasons(active.declared, pi, ctx);
+
+  if (reasons.length === 0) {
+    if (active.dirty) await markClean(ctx);
+
+    return;
+  }
+
+  if (!active.dirty) await markDirty(ctx);
+}

package/src/activation/drift.ts

@@ -0,0 +1,77 @@
+/**
+ * Drift-reason detection for active presets.
+ *
+ * Owns comparing current Pi model, thinking, and tools against a preset
+ * snapshot; it does NOT mutate active state, notify users, render UI, or
+ * read the on-disk preset files.
+ */
+import type { LoadedPreset, PresetDriftSnapshot } from "../types.js";
+import { sameSet } from "./same-set.js";
+import { effectiveThinkingLevel } from "./thinking.js";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+
+/** Minimal context surface needed for drift comparison. */
+type DriftContext = Pick<ExtensionContext, "model" | "modelRegistry">;
+
+/** Minimal Pi surface needed for drift comparison. */
+type DriftPi = Pick<ExtensionAPI, "getActiveTools" | "getThinkingLevel">;
+
+/** Return the preset dimensions whose current Pi values differ. */
+export function detectDriftReasons(
+  declared: PresetDriftSnapshot,
+  pi: DriftPi,
+  ctx: DriftContext,
+): string[] {
+  const reasons: string[] = [];
+
+  if (
+    ctx.model?.provider !== declared.provider ||
+    ctx.model.id !== declared.model
+  ) {
+    reasons.push("model");
+  }
+
+  const model = ctx.modelRegistry.find(declared.provider, declared.model);
+
+  if (
+    pi.getThinkingLevel() !==
+    effectiveThinkingLevel({ thinkingLevel: declared.thinkingLevel }, model)
+  ) {
+    reasons.push("thinking level");
+  }
+
+  if (declared.tools && declared.tools.length > 0) {
+    if (!sameSet(pi.getActiveTools(), declared.tools)) reasons.push("tools");
+  }
+
+  return reasons;
+}
+
+/**
+ * Build a drift snapshot from a freshly resolved preset.
+ *
+ * Stored on `ActivePresetState.declared` at apply / restore time so the
+ * per-turn comparison never reopens the preset JSON files. The snapshot is
+ * deliberately minimal \u2014 only the fields drift detection actually compares.
+ */
+export function snapshotPresetForDrift(
+  preset: Pick<LoadedPreset, "provider" | "model" | "thinkingLevel" | "tools">,
+): PresetDriftSnapshot {
+  const snapshot: PresetDriftSnapshot = {
+    model: preset.model,
+    provider: preset.provider,
+  };
+
+  if (preset.thinkingLevel !== undefined) {
+    snapshot.thinkingLevel = preset.thinkingLevel;
+  }
+
+  if (preset.tools !== undefined) {
+    snapshot.tools = [...preset.tools];
+  }
+
+  return snapshot;
+}

package/src/activation/same-set.ts

@@ -0,0 +1,32 @@
+/**
+ * Set-equality helpers shared across activation modules.
+ *
+ * Owns the tiny comparison primitives used by clear-decision and
+ * state-match logic; it does NOT carry any activation state or side
+ * effects. Lives here (rather than inline in each caller) because the
+ * `sameSet` literal was copy-pasted verbatim across two modules — one
+ * source of truth is easier to reason about when the comparison rules
+ * change (e.g. if we ever need to ignore case or treat `undefined` as
+ * empty).
+ */
+
+/**
+ * Compare two string arrays as unordered sets.
+ *
+ * Returns `true` when both sides contain exactly the same set of
+ * distinct values, ignoring order. Duplicate entries within either
+ * array are tolerated because the length-first guard rejects any case
+ * where duplicates would matter for set-equality purposes: if both
+ * sides have the same length and every element of `left` appears in
+ * `right`, the sets are equal.
+ */
+export function sameSet(
+  left: readonly string[],
+  right: readonly string[],
+): boolean {
+  if (left.length !== right.length) return false;
+
+  const rightSet = new Set(right);
+
+  return left.every((value) => rightSet.has(value));
+}