@sherif-fanous/pi-presets-plus 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -2,8 +2,23 @@
 
 This changelog follows [Common Changelog](https://common-changelog.org/).
 
+## [0.1.2] - 2026-05-09
+
+### Fixed
+
+- Pressing `c` (clear) inside the preset picker with no preset active no longer opens an empty confirm-then-nothing dialog. The picker now shows an info-dialog stating "No preset is active." and returns to the picker.
+- The session-start notification for a preset that shadows a Pi built-in now uses warning severity to match the visual treatment of preset-vs-preset hotkey conflicts. Both collision-style notifications render consistently.
+
+## [0.1.1] - 2026-05-09
+
+### Changed
+
+- Refactored the extension's internal architecture so the active-preset state, the runtime hotkey bindings, and the clear-summary renderer each live in a single dedicated module. No user-visible behavior change; the picker, editor, `/presets` subcommands, `--preset` flag, hotkeys, drift detection, and session restore all behave identically.
+
 ## [0.1.0] - 2026-05-09
 
 _Initial release._
 
+[0.1.2]: https://github.com/sherif-fanous/pi-presets-plus/releases/tag/v0.1.2
+[0.1.1]: https://github.com/sherif-fanous/pi-presets-plus/releases/tag/v0.1.1
 [0.1.0]: https://github.com/sherif-fanous/pi-presets-plus/releases/tag/v0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sherif-fanous/pi-presets-plus",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Pi extension: model + thinking + tools + system-prompt presets, with a UI on top.",
   "keywords": [
     "pi",

package/src/activation/apply.ts

@@ -7,12 +7,10 @@
  * picker UI.
  */
 import { ACTIVATED_MESSAGE_TYPE } from "../messages.js";
+import { samePresetIdentity } from "../preset-identity.js";
 import type { LoadedPreset } from "../types.js";
-import { updateStatus } from "../ui/status.js";
-import { getActive, setActive } from "./active-state.js";
 import { captureBaseline } from "./baseline.js";
-import { markClean } from "./dirty.js";
-import { snapshotPresetForDrift } from "./drift.js";
+import type { ActivePresetSession } from "./session.js";
 import { stateMatches } from "./state-matches.js";
 import { effectiveThinkingLevel } from "./thinking.js";
 import type {
@@ -20,14 +18,6 @@ import type {
   ExtensionContext,
 } from "@mariozechner/pi-coding-agent";
 
-/**
- * Counter (not boolean) so nested `withSelfTriggeredModelSet` calls cannot
- * silently drop the guard when the inner call's `finally` runs while the
- * outer call is still in flight. Today there is only one caller, but the
- * counter shape costs nothing and removes a footgun for future callers.
- */
-let selfTriggeredModelSetDepth = 0;
-
 /**
  * In-memory result from applying a preset.
  *
@@ -55,6 +45,7 @@ export async function apply(
   preset: LoadedPreset,
   ctx: ExtensionContext,
   pi: ExtensionAPI,
+  session: ActivePresetSession,
 ): Promise<ApplyResult> {
   if (preset.unavailable) {
     const kind = preset.unavailable;
@@ -62,15 +53,15 @@ export async function apply(
     return { ok: false, kind, reason: failureReason(kind, preset) };
   }
 
-  const current = getActive();
+  const current = session.current();
 
   if (
-    current?.name === preset.name &&
-    current.scope === preset.scope &&
+    current &&
+    samePresetIdentity(current, preset) &&
     current.restore.kind === "baseline" &&
     stateMatches(preset, pi, ctx)
   ) {
-    if (current.dirty) await markClean(ctx);
+    if (current.dirty) session.markClean(ctx);
 
     return { ok: true };
   }
@@ -92,7 +83,7 @@ export async function apply(
   const previousAppliedTools = previousBaseline?.lastApplied.tools;
   const previousOwnedTools = previousBaseline?.owned.tools ?? false;
 
-  if (!(await setModelGuarded(pi, model))) {
+  if (!(await setModelGuarded(pi, model, session))) {
     return {
       ok: false,
       kind: "key-revoked",
@@ -133,28 +124,27 @@ export async function apply(
     ownedTools = true;
   }
 
-  setActive({
-    declared: snapshotPresetForDrift({ ...preset, tools: appliedTools }),
-    dirty: false,
-    name: preset.name,
-    restore: {
+  // session.start commits the new active state (and refreshes the status
+  // badge as part of that commit) BEFORE the customType message is
+  // emitted, so observers seeing the "Preset … applied" message can
+  // already query the updated state. The reverse order — message first,
+  // status second — would briefly publish an event whose corresponding
+  // state is not yet visible.
+  session.start(
+    {
       applyCount,
       baseline,
-      kind: "baseline",
       lastApplied: {
         ...(appliedTools !== undefined ? { tools: appliedTools } : {}),
         model: { id: preset.model, provider: preset.provider },
         thinkingLevel: effective,
       },
       owned: { model: true, thinkingLevel: true, tools: ownedTools },
+      preset,
     },
-    scope: preset.scope,
-  });
-
-  pi.appendEntry("presets-plus:active", {
-    name: preset.name,
-    scope: preset.scope,
-  });
+    ctx,
+    pi,
+  );
 
   pi.sendMessage({
     customType: ACTIVATED_MESSAGE_TYPE,
@@ -167,36 +157,9 @@ export async function apply(
     },
   });
 
-  updateStatus(ctx, getActive(), (name, scope) =>
-    name === preset.name && scope === preset.scope ? preset : undefined,
-  );
-
   return { ok: true };
 }
 
-export function isSelfTriggeredModelSet(): boolean {
-  return selfTriggeredModelSetDepth > 0;
-}
-
-/**
- * Run `fn` with the self-call counter raised so a `model_select` event
- * triggered by `pi.setModel` inside `fn` is recognized as our own write
- * and ignored by the drift-detection handler. The counter shape (vs. a
- * boolean) keeps nested or concurrent calls from accidentally lowering the
- * guard while an outer call is still in flight.
- */
-export async function withSelfTriggeredModelSet<T>(
-  fn: () => Promise<T>,
-): Promise<T> {
-  selfTriggeredModelSetDepth++;
-
-  try {
-    return await fn();
-  } finally {
-    selfTriggeredModelSetDepth--;
-  }
-}
-
 function failureReason(
   kind: Exclude<ApplyResult, { ok: true }>["kind"],
   preset: Pick<LoadedPreset, "model" | "name" | "provider">,
@@ -231,6 +194,7 @@ function filterValidTools(
 async function setModelGuarded(
   pi: Pick<ExtensionAPI, "setModel">,
   model: NonNullable<ReturnType<ExtensionContext["modelRegistry"]["find"]>>,
+  session: ActivePresetSession,
 ): Promise<boolean> {
-  return withSelfTriggeredModelSet(() => pi.setModel(model));
+  return session.withSelfTriggeredModelSet(() => pi.setModel(model));
 }

package/src/activation/clear.ts

@@ -2,24 +2,20 @@
  * 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.
+ * protection) and deciding clear outcomes; it does NOT own apply, picker UI,
+ * or pure clear-summary rendering.
  */
 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";
+  formatModel,
+  formatTools,
+  renderClearSummary,
+} from "../ui/clear-summary.js";
 import { sameSet } from "./same-set.js";
+import type { ActivePresetSession } from "./session.js";
 import type {
   ExtensionAPI,
   ExtensionCommandContext,
-  Theme,
 } from "@mariozechner/pi-coding-agent";
 
 export interface ClearDecision {
@@ -45,6 +41,11 @@ export interface ClearPart {
   readonly value: string;
 }
 
+export interface ClearResult {
+  readonly name: string;
+  readonly parts: readonly ClearPart[];
+}
+
 export interface ClearSnapshot {
   readonly active: ActivePresetState;
   readonly allTools: readonly string[];
@@ -71,73 +72,12 @@ export type ClearAction =
 
 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,
+  session: ActivePresetSession,
 ): Promise<void> {
-  const result = await clearReturning(ctx, pi);
+  const result = await clearReturning(ctx, pi, session);
 
   ctx.ui.notify(
     result
@@ -150,8 +90,9 @@ export async function clear(
 export async function clearReturning(
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI,
+  session: ActivePresetSession,
 ): Promise<ClearResult | undefined> {
-  const active = getActive();
+  const active = session.current();
 
   if (!active) return undefined;
 
@@ -165,11 +106,9 @@ export async function clearReturning(
     currentThinking: pi.getThinkingLevel(),
     currentTools: pi.getActiveTools(),
   });
-  const finalParts = await executeClear(decision, ctx, pi);
+  const finalParts = await executeClear(decision, ctx, pi, session);
 
-  clearActive();
-  pi.appendEntry("presets-plus:active", { name: null });
-  updateStatus(ctx, getActive(), () => undefined);
+  session.clear(ctx, pi);
 
   return { name: active.name, parts: finalParts };
 }
@@ -293,32 +232,11 @@ export function decideClear(snapshot: ClearSnapshot): ClearDecision {
   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">,
+  session: ActivePresetSession,
 ): Promise<ClearPart[]> {
   const parts = decision.parts.map((part) => ({ ...part }));
 
@@ -326,7 +244,7 @@ async function executeClear(
     const target = decision.writes.model;
     const model = ctx.modelRegistry.find(target.provider, target.id);
     const ok = model
-      ? await withSelfTriggeredModelSet(() => pi.setModel(model))
+      ? await session.withSelfTriggeredModelSet(() => pi.setModel(model))
       : false;
 
     if (!ok) {
@@ -353,79 +271,6 @@ async function executeClear(
   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,

package/src/activation/drift-handlers.ts

@@ -7,10 +7,8 @@
  * `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 { ActivePresetSession } from "./session.js";
 import type {
   ExtensionAPI,
   ExtensionContext,
@@ -43,29 +41,33 @@ export async function handleModelSelectDrift(
   event: ModelSelectLikeEvent,
   ctx: DriftHandlerContext,
   pi: DriftHandlerPi,
+  session: ActivePresetSession,
 ): Promise<void> {
-  if (isSelfTriggeredModelSet()) return;
+  if (session.isSelfTriggered()) return;
   if (event.source === "restore") return;
 
-  await syncDirtyFromCurrentState(ctx, pi);
+  await syncDirtyFromCurrentState(ctx, pi, session);
 }
 
 /** Recompute all drift reasons and update the dirty flag if needed. */
 export async function syncDirtyFromCurrentState(
   ctx: DriftHandlerContext,
   pi: DriftHandlerPi,
+  session: ActivePresetSession,
 ): Promise<void> {
-  const active = getActive();
+  const active = session.current();
 
   if (!active) return;
 
   const reasons = detectDriftReasons(active.declared, pi, ctx);
 
   if (reasons.length === 0) {
-    if (active.dirty) await markClean(ctx);
+    if (active.dirty) session.markClean(ctx);
 
     return;
   }
 
-  if (!active.dirty) await markDirty(ctx);
+  if (!active.dirty) session.markDirty(ctx);
+
+  await Promise.resolve();
 }