@sherif-fanous/pi-presets-plus 0.1.0

package/src/activation/state-matches.ts

@@ -0,0 +1,29 @@
+/**
+ * Current-state comparison for active presets.
+ *
+ * Owns deciding whether pi's current state already matches a preset; it
+ * does NOT mutate state or notify users.
+ */
+import type { LoadedPreset } from "../types.js";
+import { detectDriftReasons, snapshotPresetForDrift } from "./drift.js";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+
+/** Minimal context surface needed for comparison. */
+type StateMatchesContext = Pick<ExtensionContext, "model" | "modelRegistry">;
+
+/** Minimal pi surface needed for comparison. */
+type StateMatchesPi = Pick<ExtensionAPI, "getActiveTools" | "getThinkingLevel">;
+
+/** Return true when current model/thinking/tools equal declared preset state. */
+export function stateMatches(
+  preset: LoadedPreset,
+  pi: StateMatchesPi,
+  ctx: StateMatchesContext,
+): boolean {
+  return (
+    detectDriftReasons(snapshotPresetForDrift(preset), pi, ctx).length === 0
+  );
+}

package/src/activation/thinking.ts

@@ -0,0 +1,54 @@
+/**
+ * Thinking-level capability helpers for preset activation.
+ *
+ * Owns the mapping from a resolved model to the thinking levels a preset
+ * may legally apply; it does NOT mutate pi state or surface notifications.
+ */
+import type { Preset, ThinkingLevel } from "../types.js";
+import type { Api, Model } from "@mariozechner/pi-ai";
+
+const ALL_THINKING_LEVELS: readonly ThinkingLevel[] = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+] as const;
+
+/** Return the level pi will effectively use for the preset/model pair. */
+export function effectiveThinkingLevel(
+  preset: Pick<Preset, "thinkingLevel">,
+  model: Model<Api> | undefined,
+): ThinkingLevel {
+  const declared = preset.thinkingLevel ?? "off";
+
+  return validThinkingLevels(model).includes(declared) ? declared : "off";
+}
+
+/**
+ * Return the levels meaningful for a model; unknown models are permissive.
+ *
+ * `model.reasoning === false` is authoritative and allows only `"off"`.
+ * Reasoning models mirror pi-ai's supported-level parser: a level is
+ * unsupported when the map explicitly stores `null`; missing keys fall through
+ * to provider defaults for levels through `"high"`; `"xhigh"` must be
+ * explicitly mapped to a non-null value. Optional-chained reads keep older
+ * pi-ai bundles that predate `thinkingLevelMap` on the legacy up-to-high
+ * behavior.
+ */
+export function validThinkingLevels(
+  model: Model<Api> | undefined,
+): ThinkingLevel[] {
+  if (!model) return [...ALL_THINKING_LEVELS];
+  if (model.reasoning === false) return ["off"];
+
+  return ALL_THINKING_LEVELS.filter((level) => {
+    const mapped = model.thinkingLevelMap?.[level];
+
+    if (mapped === null) return false;
+    if (level === "xhigh") return mapped !== undefined;
+
+    return true;
+  });
+}

package/src/commands/presets/clear.ts

@@ -0,0 +1,18 @@
+/**
+ * `/presets clear` command runner.
+ *
+ * Owns command-bound delegation to the activation clear engine; restore
+ * semantics live in `activation/clear.ts`.
+ */
+import { clear } from "../../activation/clear.js";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@mariozechner/pi-coding-agent";
+
+export async function runClear(
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<void> {
+  await clear(ctx, pi);
+}

package/src/commands/presets/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Public entry points for the `/presets` command.
+ *
+ * Owns the barrel that the extension entry point imports from; it does
+ * NOT own subcommand routing or implementation details.
+ */
+
+export { getArgumentCompletions, handlePresetsCommand } from "./router.js";
+export { surfaceWarnings } from "./notify.js";

package/src/commands/presets/notify.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared notification helper for `/presets` subcommands.
+ *
+ * Owns rolling load-time warnings into a single user-visible notification
+ * so callers do not flood the UI; it does NOT own loading or validation.
+ */
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+/**
+ * Fire a single warning-level notification listing every warning, or
+ * no-op when the list is empty.
+ */
+export function surfaceWarnings(
+  ctx: Pick<ExtensionContext, "ui">,
+  warnings: readonly string[],
+): void {
+  if (warnings.length === 0) return;
+  ctx.ui.notify(
+    `${warnings.length} preset warning${warnings.length === 1 ? "" : "s"}:\n- ${warnings.join("\n- ")}`,
+    "warning",
+  );
+}

package/src/commands/presets/reload.ts

@@ -0,0 +1,28 @@
+/**
+ * `/presets reload` command runner.
+ *
+ * Owns re-reading both scope files on demand and reporting the result to
+ * the user as a single notification; it does NOT own the underlying
+ * storage layer or activation state.
+ */
+import { loadAll } from "../../store/api.js";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+/**
+ * Run the `reload` subcommand against a live `ExtensionContext`.
+ */
+export async function runReload(ctx: ExtensionContext): Promise<void> {
+  const { presets, warnings } = await loadAll(ctx);
+  const summary = `Reloaded ${presets.length} preset${presets.length === 1 ? "" : "s"}.`;
+
+  if (warnings.length === 0) {
+    ctx.ui.notify(summary, "info");
+
+    return;
+  }
+
+  ctx.ui.notify(
+    `${summary}\n${warnings.length} warning${warnings.length === 1 ? "" : "s"}:\n- ${warnings.join("\n- ")}`,
+    "warning",
+  );
+}

package/src/commands/presets/router.ts

@@ -0,0 +1,139 @@
+/**
+ * `/presets` subcommand router.
+ *
+ * Owns command token dispatch and autocomplete for the `/presets` command;
+ * storage, activation, picker, and clear semantics live in their dedicated
+ * modules.
+ */
+import { apply } from "../../activation/apply.js";
+import { openPicker } from "../../ui/picker.js";
+import { runClear } from "./clear.js";
+import { runReload } from "./reload.js";
+import { runStatus } from "./status.js";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@mariozechner/pi-coding-agent";
+
+interface Subcommand {
+  readonly value: string;
+  readonly label: string;
+  run(
+    ctx: ExtensionCommandContext,
+    args: readonly string[],
+    pi?: ExtensionAPI,
+  ): Promise<void>;
+}
+
+const SUBCOMMANDS: readonly Subcommand[] = [
+  {
+    value: "reload",
+    label: "reload: re-read both scope files",
+    run: runReloadWrapper,
+  },
+  {
+    value: "clear",
+    label: "clear: clear the active preset",
+    run: runClearWrapper,
+  },
+  {
+    value: "status",
+    label: "status: show active preset details",
+    run: runStatusWrapper,
+  },
+] as const;
+
+export function getArgumentCompletions(
+  prefix: string,
+): { value: string; label: string }[] {
+  const trimmedPrefix = prefix.trimStart();
+
+  if (trimmedPrefix.includes(" ")) return [];
+
+  return SUBCOMMANDS.filter((subcommand) =>
+    subcommand.value.startsWith(trimmedPrefix),
+  ).map(({ value, label }) => ({ value, label }));
+}
+
+export async function handlePresetsCommand(
+  args: string,
+  ctx: ExtensionCommandContext,
+  pi?: ExtensionAPI,
+): Promise<void> {
+  const trimmedArgs = args.trim();
+
+  if (trimmedArgs.length === 0) {
+    await runPicker(ctx, pi);
+
+    return;
+  }
+
+  const tokens = trimmedArgs.split(/\s+/);
+  const subCommand = tokens[0] ?? "";
+
+  if (subCommand === "list") {
+    ctx.ui.notify(
+      '"list" is not a supported /presets subcommand. Run /presets to open the picker.',
+      "warning",
+    );
+
+    return;
+  }
+
+  const target = SUBCOMMANDS.find(
+    (subcommand) => subcommand.value === subCommand,
+  );
+
+  if (target) {
+    await target.run(ctx, tokens.slice(1), pi);
+
+    return;
+  }
+
+  ctx.ui.notify(
+    `unknown subcommand "${subCommand ?? ""}". try /presets, /presets reload, /presets clear, or /presets status.`,
+    "warning",
+  );
+}
+
+async function runClearWrapper(
+  ctx: ExtensionCommandContext,
+  _args: readonly string[],
+  pi?: ExtensionAPI,
+): Promise<void> {
+  if (!pi) return;
+  await runClear(ctx, pi);
+}
+
+async function runPicker(
+  ctx: ExtensionCommandContext,
+  pi?: ExtensionAPI,
+): Promise<void> {
+  if (!pi) {
+    ctx.ui.notify(
+      "Preset picker is only available in interactive mode.",
+      "warning",
+    );
+
+    return;
+  }
+
+  await openPicker(ctx, {
+    inheritedTools: pi.getActiveTools(),
+    onActivate: (preset) => apply(preset, ctx, pi),
+    pi,
+  });
+}
+
+async function runReloadWrapper(ctx: ExtensionCommandContext): Promise<void> {
+  await runReload(ctx);
+}
+
+async function runStatusWrapper(
+  ctx: ExtensionCommandContext,
+  _args: readonly string[],
+  pi?: ExtensionAPI,
+): Promise<void> {
+  if (!pi) return;
+  await runStatus(ctx, pi);
+}

package/src/commands/presets/status.ts

@@ -0,0 +1,262 @@
+/**
+ * `/presets status` textual diagnostic.
+ *
+ * Owns formatting the active preset and its baseline-overlay state into a
+ * user-facing report; it does NOT update the footer indicator or mutate
+ * the active attachment.
+ */
+import { getActive } from "../../activation/active-state.js";
+import { loadAll } from "../../store/api.js";
+import type { LoadedPreset } from "../../types.js";
+import {
+  BASELINE_MODEL_LABEL,
+  BASELINE_THINKING_LABEL,
+  BASELINE_TOOLS_LABEL,
+  CURRENT_MODEL_LABEL,
+  CURRENT_THINKING_LABEL,
+  CURRENT_TOOLS_LABEL,
+  PRESET_LABEL,
+  PRESET_MODEL_LABEL,
+  PRESET_THINKING_LABEL,
+  PRESET_TOOLS_LABEL,
+  RESTORE_LABEL,
+  SCOPE_LABEL,
+  STATUS_DIALOG_TITLE,
+} from "../../ui/labels.js";
+import { surfaceWarnings } from "./notify.js";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  Theme,
+} from "@mariozechner/pi-coding-agent";
+
+export interface StatusBodyResult {
+  readonly body: string;
+  readonly severity: "info" | "warning";
+  readonly warnings: readonly string[];
+}
+
+interface Styler {
+  bold(text: string): string;
+  fg(color: string, text: string): string;
+}
+
+const IDENTITY_STYLER: Styler = {
+  bold: (text) => text,
+  fg: (_color, text) => text,
+};
+const STATUS_LABELS = [
+  `${PRESET_LABEL}:`,
+  `${SCOPE_LABEL}:`,
+  `${RESTORE_LABEL}:`,
+  `${BASELINE_MODEL_LABEL}:`,
+  `${BASELINE_THINKING_LABEL}:`,
+  `${BASELINE_TOOLS_LABEL}:`,
+  `${PRESET_MODEL_LABEL}:`,
+  `${PRESET_THINKING_LABEL}:`,
+  `${PRESET_TOOLS_LABEL}:`,
+  `${CURRENT_MODEL_LABEL}:`,
+  `${CURRENT_THINKING_LABEL}:`,
+  `${CURRENT_TOOLS_LABEL}:`,
+] as const;
+const STATUS_LABEL_WIDTH = Math.max(
+  ...STATUS_LABELS.map((label) => label.length),
+);
+
+export function formatStatus(
+  active: ReturnType<typeof getActive>,
+  _preset: LoadedPreset,
+  ctx: Pick<ExtensionCommandContext, "model">,
+  pi: Pick<ExtensionAPI, "getActiveTools" | "getThinkingLevel">,
+  styler: Pick<Theme, "bold" | "fg"> = IDENTITY_STYLER,
+): string {
+  if (!active) return "No preset is active.";
+
+  const currentModel = ctx.model
+    ? { provider: ctx.model.provider, id: ctx.model.id }
+    : null;
+  const currentTools = pi.getActiveTools();
+
+  if (active.restore.kind === "unknown") {
+    return [
+      styler.bold(styler.fg("accent", STATUS_DIALOG_TITLE)),
+      row(`${PRESET_LABEL}:`, active.name, styler),
+      row(`${SCOPE_LABEL}:`, active.scope, styler),
+      row(
+        `${RESTORE_LABEL}:`,
+        "No saved baseline. Clear will only turn the preset off.",
+        styler,
+      ),
+      row(`${CURRENT_MODEL_LABEL}:`, formatModel(currentModel), styler),
+      row(`${CURRENT_THINKING_LABEL}:`, pi.getThinkingLevel(), styler),
+      row(`${CURRENT_TOOLS_LABEL}:`, formatTools(currentTools), styler),
+    ].join("\n");
+  }
+
+  const { baseline, lastApplied, owned } = active.restore;
+  const modelClass = classifyField(
+    currentModel,
+    baseline.model,
+    lastApplied.model,
+  );
+  const thinkingClass = classifyField(
+    pi.getThinkingLevel(),
+    baseline.thinkingLevel,
+    lastApplied.thinkingLevel,
+  );
+  const toolsClass = owned.tools
+    ? classifyField(currentTools, baseline.tools, lastApplied.tools ?? [])
+    : "Not managed by active preset";
+
+  return [
+    styler.bold(styler.fg("accent", STATUS_DIALOG_TITLE)),
+    row(`${PRESET_LABEL}:`, active.name, styler),
+    row(`${SCOPE_LABEL}:`, active.scope, styler),
+    row(`${BASELINE_MODEL_LABEL}:`, formatModel(baseline.model), styler),
+    row(`${BASELINE_THINKING_LABEL}:`, baseline.thinkingLevel, styler),
+    row(`${BASELINE_TOOLS_LABEL}:`, formatTools(baseline.tools), styler),
+    row(`${PRESET_MODEL_LABEL}:`, formatModel(lastApplied.model), styler),
+    row(`${PRESET_THINKING_LABEL}:`, lastApplied.thinkingLevel, styler),
+    row(
+      `${PRESET_TOOLS_LABEL}:`,
+      lastApplied.tools ? formatTools(lastApplied.tools) : "none",
+      styler,
+    ),
+    row(
+      `${CURRENT_MODEL_LABEL}:`,
+      `${formatModel(currentModel)} (${modelClass})`,
+      styler,
+    ),
+    row(
+      `${CURRENT_THINKING_LABEL}:`,
+      `${pi.getThinkingLevel()} (${thinkingClass})`,
+      styler,
+    ),
+    row(
+      `${CURRENT_TOOLS_LABEL}:`,
+      `${formatTools(currentTools)} (${toolsClass})`,
+      styler,
+    ),
+  ].join("\n");
+}
+
+export async function formatStatusBody(
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<StatusBodyResult> {
+  const active = getActive();
+
+  if (!active) {
+    return { body: "No preset is active.", severity: "info", warnings: [] };
+  }
+
+  const { presets, warnings } = await loadAll(ctx);
+  const preset = presets.find(
+    (candidate) =>
+      candidate.name === active.name && candidate.scope === active.scope,
+  );
+
+  if (!preset) {
+    return {
+      body: `Active preset "${active.name}" is no longer loaded.`,
+      severity: "warning",
+      warnings,
+    };
+  }
+
+  return {
+    body: formatStatus(active, preset, ctx, pi, ctx.ui.theme),
+    severity: "info",
+    warnings,
+  };
+}
+
+export async function runStatus(
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<void> {
+  const result = await formatStatusBody(ctx, pi);
+
+  surfaceWarnings(ctx, result.warnings);
+  ctx.ui.notify(result.body, result.severity);
+}
+
+/**
+ * Compare a current value against the baseline and last-applied snapshots
+ * and return a plain-English label.
+ *
+ * Vocabulary parallels the per-row annotations in `renderClearSummary` so
+ * users see the same phrasing across `/presets status` and `/presets clear`.
+ * `compare` is `===` for primitives and bag-equality for tool arrays;
+ * model objects compare provider+id.
+ */
+function classifyField(
+  current: { provider: string; id: string } | null | readonly string[] | string,
+  baseline:
+    | { provider: string; id: string }
+    | null
+    | readonly string[]
+    | string,
+  lastApplied: { provider: string; id: string } | readonly string[] | string,
+):
+  | "Already at baseline"
+  | "Left as-is — you changed it after activation"
+  | "Managed by active preset" {
+  if (sameComparable(current, baseline)) return "Already at baseline";
+  if (sameComparable(current, lastApplied)) return "Managed by active preset";
+
+  return "Left as-is — you changed it after activation";
+}
+
+function formatModel(model: { provider: string; id: string } | null): string {
+  return model ? `${model.provider}/${model.id}` : "none";
+}
+
+function formatTools(tools: readonly string[]): string {
+  return tools.length > 0 ? tools.join(", ") : "none";
+}
+
+function row(
+  label: (typeof STATUS_LABELS)[number],
+  value: string,
+  styler: Pick<Theme, "fg">,
+): string {
+  const padding = " ".repeat(STATUS_LABEL_WIDTH - label.length);
+
+  return `  ${styler.fg("muted", label)}${padding} ${value}`;
+}
+
+function sameComparable(
+  left: { provider: string; id: string } | null | readonly string[] | string,
+  right: { provider: string; id: string } | null | readonly string[] | string,
+): boolean {
+  const leftIsArray = Array.isArray(left);
+  const rightIsArray = Array.isArray(right);
+
+  if (leftIsArray || rightIsArray) {
+    if (!leftIsArray || !rightIsArray) return false;
+
+    const leftArr = left as readonly string[];
+    const rightArr = right as readonly string[];
+
+    if (leftArr.length !== rightArr.length) return false;
+
+    const rightSet = new Set(rightArr);
+
+    return leftArr.every((value) => rightSet.has(value));
+  }
+
+  if (typeof left === "string" || typeof right === "string") {
+    return (
+      typeof left === "string" && typeof right === "string" && left === right
+    );
+  }
+
+  const leftModel = left as { provider: string; id: string } | null;
+  const rightModel = right as { provider: string; id: string } | null;
+
+  return (
+    leftModel?.provider === rightModel?.provider &&
+    leftModel?.id === rightModel?.id
+  );
+}

package/src/flag.ts

@@ -0,0 +1,88 @@
+/**
+ * Startup preset flag registration and handling.
+ *
+ * Owns the `--preset` CLI flag entry point and startup lookup messages. It
+ * does NOT own session restore, preset storage, or the apply implementation.
+ */
+import { apply } from "./activation/apply.js";
+import type { LoadedPreset } from "./types.js";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+
+const PRESET_FLAG = "preset";
+
+export async function applyPresetFlag(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  presets: readonly LoadedPreset[],
+): Promise<void> {
+  const value = pi.getFlag(PRESET_FLAG);
+
+  if (typeof value !== "string") return;
+
+  const name = value.trim();
+
+  if (name.length === 0) return;
+
+  const preset = findPresetForFlag(presets, name);
+
+  if (!preset) {
+    ctx.ui.notify(
+      `--preset: Unknown preset "${name}". Available: ${formatAvailableNames(presets)}.`,
+      "warning",
+    );
+
+    return;
+  }
+
+  const result = await apply(preset, ctx, pi);
+
+  if (!result.ok) ctx.ui.notify(result.reason, "error");
+}
+
+export function registerPresetFlag(
+  pi: Pick<ExtensionAPI, "registerFlag">,
+): void {
+  pi.registerFlag(PRESET_FLAG, {
+    description: "Activate the named pi-presets-plus preset on session start.",
+    type: "string",
+  });
+}
+
+function findPresetForFlag(
+  presets: readonly LoadedPreset[],
+  name: string,
+): LoadedPreset | undefined {
+  return (
+    presets.find(
+      (preset) =>
+        preset.name === name && preset.scope === "project" && !preset.shadowed,
+    ) ??
+    presets.find(
+      (preset) =>
+        preset.name === name && preset.scope === "user" && !preset.shadowed,
+    )
+  );
+}
+
+function formatAvailableNames(presets: readonly LoadedPreset[]): string {
+  const byName = new Map<string, LoadedPreset>();
+
+  for (const preset of presets) {
+    const existing = byName.get(preset.name);
+
+    if (!existing || existing.shadowed) byName.set(preset.name, preset);
+  }
+
+  if (byName.size === 0) return "none";
+
+  return [...byName.values()]
+    .map((preset) =>
+      preset.unavailable
+        ? `${preset.name} (Unavailable: ${preset.unavailable})`
+        : preset.name,
+    )
+    .join(", ");
+}