@mrclrchtr/supi-extras 8.0.1 → 9.0.0

package/src/session-capabilities-ui.ts

@@ -9,7 +9,11 @@ import {
   truncateToWidth,
   visibleWidth,
 } from "@earendil-works/pi-tui";
-import type { SessionCapabilitySkill, SessionCapabilityState } from "@mrclrchtr/supi-core/session";
+import {
+  isSessionCapabilityProfileModified,
+  type SessionCapabilitySkill,
+  type SessionCapabilityState,
+} from "@mrclrchtr/supi-core/session";
 import {
   createSelectListMenu,
   formatTuiTitleLine,
@@ -19,13 +23,20 @@ import {
 } from "@mrclrchtr/supi-core/tui";
 import {
   buildCapabilityRows,
+  type CapabilityProfileAction,
   type CapabilityRow,
   type CapabilitySection,
   type CapabilityToolItem,
 } from "./session-capabilities-ui-rows.ts";
 
-export type { CapabilityToolItem } from "./session-capabilities-ui-rows.ts";
+export type {
+  CapabilityProfileAction,
+  CapabilityRow,
+  CapabilitySection,
+  CapabilityToolItem,
+} from "./session-capabilities-ui-rows.ts";
 
+const SECTIONS: CapabilitySection[] = ["tools", "skills", "profiles"];
 const MAX_VISIBLE_ROWS = 10;
 const HEADER_HEIGHT = 2;
 
@@ -37,8 +48,12 @@ interface SelectorComponent {
 }
 
 interface CapabilitySelectorOptions {
-  done: (result: undefined) => void;
+  done: (result: CapabilityProfileAction | undefined) => void;
   onChange: (id: string, value: string) => void;
+  /** Rows read from profile configuration before this selector opens. */
+  profileRows?: CapabilityRow[];
+  /** Reopen Profiles after a profile action. Defaults to Tools. */
+  initialSection?: CapabilitySection;
   skills: SessionCapabilitySkill[] | undefined;
   state: SessionCapabilityState;
   theme: ExtensionUIContext["theme"];
@@ -124,12 +139,7 @@ class CapabilityList implements SelectorComponent {
   }
 
   private buildRows(): CapabilityRow[] {
-    return buildCapabilityRows(
-      this.section,
-      this.options.tools,
-      this.options.skills,
-      this.options.state,
-    );
+    return buildCapabilityRows({ ...this.options, section: this.section });
   }
 
   private filteredRows(): CapabilityRow[] {
@@ -206,7 +216,13 @@ class CapabilityList implements SelectorComponent {
 
   private renderHint(width: number): string {
     return renderTuiHintLine(
-      ["Type to search", "Enter for actions", "Space to toggle", "Tab to switch", "Esc to close"],
+      [
+        "Type to search",
+        "Enter for actions",
+        ...(this.section === "profiles" ? [] : ["Space to toggle"]),
+        "Tab to switch",
+        "Esc to close",
+      ],
       this.options.theme,
       width,
     );
@@ -268,8 +284,7 @@ class CapabilityList implements SelectorComponent {
     const row = this.filteredRows()[this.selectedIndex];
     if (!row?.toggleValues) return;
     const [enabledValue, disabledValue] = row.toggleValues;
-    this.options.onChange(row.id, row.currentValue === enabledValue ? disabledValue : enabledValue);
-    this.refreshRows(row.id);
+    this.changeRow(row.id, row.currentValue === enabledValue ? disabledValue : enabledValue);
   }
 
   private activateSelected(): void {
@@ -281,8 +296,7 @@ class CapabilityList implements SelectorComponent {
       theme: this.options.theme,
       onSelect: (item) => {
         this.menu = null;
-        this.options.onChange(row.id, item.value);
-        this.refreshRows(row.id);
+        this.changeRow(row.id, item.value);
       },
       onCancel: () => {
         this.menu = null;
@@ -294,6 +308,15 @@ class CapabilityList implements SelectorComponent {
     this.options.tui.requestRender();
   }
 
+  private changeRow(id: string, value: string): void {
+    if (id.startsWith("profile:")) {
+      this.options.done({ id, value });
+      return;
+    }
+    this.options.onChange(id, value);
+    this.refreshRows(id);
+  }
+
   private refreshRows(selectedId: string): void {
     this.rows = this.buildRows();
     const rows = this.filteredRows();
@@ -308,17 +331,25 @@ class CapabilityList implements SelectorComponent {
 /** Build the searchable selector for the current session. */
 export function createCapabilitySelector(options: CapabilitySelectorOptions): SelectorComponent {
   const { theme, tui } = options;
-  let section: CapabilitySection = "tools";
+  let section: CapabilitySection = options.initialSection ?? "tools";
   let list = new CapabilityList(section, options);
   const topBorder = new DynamicBorder((text: string) => theme.fg("borderMuted", text));
   const bottomBorder = new DynamicBorder((text: string) => theme.fg("borderMuted", text));
 
   const renderTitle = (width: number): string => {
-    const tabs =
-      section === "tools"
-        ? `${theme.fg("accent", theme.bold("[Tools]"))}  ${theme.fg("dim", "Skills")}`
-        : `${theme.fg("dim", "Tools")}  ${theme.fg("accent", theme.bold("[Skills]"))}`;
-    return truncateToWidth(formatTuiTitleLine("Session Capabilities", theme, tabs), width);
+    const tabs = SECTIONS.map((tab) => {
+      const label = tab.charAt(0).toUpperCase() + tab.slice(1);
+      return tab === section
+        ? theme.fg("accent", theme.bold(`[${label}]`))
+        : theme.fg("dim", label);
+    }).join("  ");
+    const snapshot = options.state.profileSnapshot;
+    const profile = snapshot ? ` · ${snapshot.id} (${snapshot.source})` : "";
+    const modified = isSessionCapabilityProfileModified(options.state) ? " · Modified" : "";
+    return truncateToWidth(
+      formatTuiTitleLine(`Session Capabilities${profile}${modified}`, theme, tabs),
+      width,
+    );
   };
 
   return {
@@ -336,8 +367,11 @@ export function createCapabilitySelector(options: CapabilitySelectorOptions): Se
       list.invalidate();
     },
     handleInput(data) {
-      if (matchesKey(data, Key.tab) && !list.hasOpenMenu()) {
-        section = section === "tools" ? "skills" : "tools";
+      const reverse = matchesKey(data, Key.shift("tab"));
+      if ((matchesKey(data, Key.tab) || reverse) && !list.hasOpenMenu()) {
+        const index =
+          (SECTIONS.indexOf(section) + (reverse ? -1 : 1) + SECTIONS.length) % SECTIONS.length;
+        section = SECTIONS[index] ?? "tools";
         list = new CapabilityList(section, options);
         tui.requestRender();
         return;

package/src/session-capabilities.ts

@@ -6,11 +6,13 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { FOOTER_INVALIDATE_EVENT, footerContributions } from "@mrclrchtr/supi-core/footer-registry";
 import {
+  applySessionCapabilityProfile,
   clearPendingSessionCapabilityForks,
   createEmptySessionCapabilityState,
   decodeSessionCapabilities,
   findSessionCapabilities,
   getSessionCapabilitySkillProvider,
+  isSessionCapabilityProfileModified,
   readPendingSessionCapabilityFork,
   SESSION_CAPABILITIES_ENTRY,
   type SessionCapabilitySkill,
@@ -18,6 +20,7 @@ import {
   sessionCapabilityState,
   setPendingSessionCapabilityFork,
 } from "@mrclrchtr/supi-core/session";
+import { openCapabilitySelector } from "./session-capabilities-selector.ts";
 import {
   addActiveToolsToBaseline,
   baselineFromState,
@@ -31,7 +34,8 @@ import {
   observeNewTools,
   reconcileToolInventory,
 } from "./session-capabilities-tools.ts";
-import { type CapabilityToolItem, createCapabilitySelector } from "./session-capabilities-ui.ts";
+import type { CapabilityToolItem } from "./session-capabilities-ui.ts";
+import { createCapabilityProfileStore } from "./session-capability-profile-store.ts";
 
 const COMMAND_NAME = "supi-capabilities";
 const FOOTER_KEY = "supi-capabilities";
@@ -60,11 +64,15 @@ function updateFooter(
     state.toolDenylist.length +
     (state.toolEnabledNames?.length ?? 0) +
     state.hiddenSkillNames.length;
-  if (count === 0) {
+  const profile = state.profileSnapshot;
+  if (count === 0 && !profile) {
     footerContributions.unregister(FOOTER_KEY);
     ctx.ui.setStatus(FOOTER_KEY, undefined);
   } else {
-    const render = (): string => ctx.ui.theme.fg("accent", `${FOOTER_ICON}${count}`);
+    const label = profile
+      ? ` ${profile.id}${isSessionCapabilityProfileModified(state) ? " Modified" : ""}`
+      : "";
+    const render = (): string => ctx.ui.theme.fg("accent", `${FOOTER_ICON}${count}${label}`);
     footerContributions.register({ key: FOOTER_KEY, placement: "stats-end", render });
     ctx.ui.setStatus(FOOTER_KEY, render());
   }
@@ -125,21 +133,6 @@ function restoreAllTools(
   applyToolDenylist(pi, state, restoreNames, restorableNames);
 }
 
-function resetTools(
-  pi: ExtensionAPI,
-  ctx: ExtensionContext,
-  state: SessionCapabilityState,
-  restorableNames: ReadonlySet<string>,
-): void {
-  restoreAllTools(pi, state, restorableNames);
-  saveState(pi, ctx, state);
-}
-
-function resetSkills(pi: ExtensionAPI, ctx: ExtensionContext, state: SessionCapabilityState): void {
-  state.hiddenSkillNames = [];
-  saveState(pi, ctx, state);
-}
-
 function resetAll(
   pi: ExtensionAPI,
   ctx: ExtensionContext,
@@ -148,6 +141,7 @@ function resetAll(
 ): void {
   restoreAllTools(pi, state, restorableNames);
   state.hiddenSkillNames = [];
+  delete state.profileSnapshot;
   saveState(pi, ctx, state);
 }
 
@@ -198,14 +192,18 @@ function handleSelectorChange(options: SelectorChangeOptions): void {
       saveState(pi, ctx, state);
       return;
     case "hide-all-skills":
-      state.hiddenSkillNames = Array.from(new Set((skills ?? []).map((skill) => skill.name)));
+      state.hiddenSkillNames = Array.from(
+        new Set([...state.hiddenSkillNames, ...(skills ?? []).map((skill) => skill.name)]),
+      );
       saveState(pi, ctx, state);
       return;
     case "reset-tools":
-      resetTools(pi, ctx, state, options.restorableNames);
+      restoreAllTools(pi, state, options.restorableNames);
+      saveState(pi, ctx, state);
       return;
     case "reset-skills":
-      resetSkills(pi, ctx, state);
+      state.hiddenSkillNames = [];
+      saveState(pi, ctx, state);
       return;
     case "reset-all":
       resetAll(pi, ctx, state, options.restorableNames);
@@ -224,8 +222,51 @@ function handleSelectorChange(options: SelectorChangeOptions): void {
   }
 }
 
-/** Register session-only controls for extension tools and model-visible skills. */
-export default function sessionCapabilities(pi: ExtensionAPI): void {
+/** Check all branches for history. Initial model and thinking entries are not history. */
+function shouldApplyDefault(
+  ctx: ExtensionContext,
+  reason: string,
+  storedState: SessionCapabilityState | undefined,
+): boolean {
+  if (reason === "new") return true;
+  if (reason !== "startup" || storedState || ctx.sessionManager.getHeader()?.parentSession)
+    return false;
+  return !ctx.sessionManager
+    .getEntries()
+    .some((entry) =>
+      ["message", "custom_message", "compaction", "branch_summary", "context_edit"].includes(
+        entry.type,
+      ),
+    );
+}
+
+function applyDefaultProfile(
+  state: SessionCapabilityState,
+  ctx: ExtensionContext,
+  homeDir: string | undefined,
+): SessionCapabilityState {
+  const catalog = createCapabilityProfileStore({
+    cwd: ctx.cwd,
+    homeDir,
+    isProjectTrusted: () => ctx.isProjectTrusted(),
+  }).read();
+  for (const error of catalog.errors) {
+    const message = `Session capability profiles (${error.scope}, ${error.path}): ${error.message}`;
+    if (ctx.mode === "print" || ctx.mode === "json") {
+      // biome-ignore lint/suspicious/noConsole: non-interactive startup has no notification UI
+      console.warn(message);
+    } else ctx.ui.notify(message, "warning");
+  }
+  return catalog.default.status === "resolved"
+    ? (applySessionCapabilityProfile(state, catalog.default.profile) ?? state)
+    : state;
+}
+
+/** Register session controls and saved profiles for extension tools and model-visible skills. */
+export default function sessionCapabilities(
+  pi: ExtensionAPI,
+  options: { homeDir?: string } = {},
+): void {
   let toolBaseline: ToolBaseline | undefined;
   let knownToolNames = new Set<string>();
   let restorableToolNames = new Set<string>();
@@ -237,6 +278,8 @@ export default function sessionCapabilities(pi: ExtensionAPI): void {
         return;
       }
 
+      if (!ctx.isIdle()) ctx.ui.notify("Waiting for the agent to become idle.", "info");
+      await ctx.waitForIdle();
       const sessionId = ctx.sessionManager.getSessionId();
       const state =
         currentSessionState(ctx) ??
@@ -250,36 +293,37 @@ export default function sessionCapabilities(pi: ExtensionAPI): void {
       if (provider) {
         try {
           skills = await provider.listEligibleSkills(ctx);
-          const names = new Set(skills.map((skill) => skill.name));
-          const previous = state.hiddenSkillNames;
-          state.hiddenSkillNames = previous.filter((name) => names.has(name));
-          if (previous.length !== state.hiddenSkillNames.length) saveState(pi, ctx, state);
         } catch {
           ctx.ui.notify("Could not load the skill list", "warning");
         }
       }
 
-      await ctx.ui.custom((tui, theme, _keybindings, done) =>
-        createCapabilitySelector({
-          state,
-          tools: toolInventory.tools,
-          skills,
-          theme,
-          tui,
-          done,
-          onChange: (id, value) =>
-            handleSelectorChange({
-              pi,
-              ctx,
-              state,
-              tools: toolInventory.tools,
-              skills,
-              id,
-              value,
-              restorableNames: restorableToolNames,
-            }),
-        }),
-      );
+      await openCapabilitySelector({
+        ctx,
+        homeDir: options.homeDir,
+        state,
+        tools: toolInventory.tools,
+        skills,
+        onChange: (id, value) =>
+          handleSelectorChange({
+            pi,
+            ctx,
+            state,
+            tools: toolInventory.tools,
+            skills,
+            id,
+            value,
+            restorableNames: restorableToolNames,
+          }),
+        onApply: (profile) => {
+          const next = applySessionCapabilityProfile(state, profile);
+          if (!next) throw new Error("Invalid session capability profile.");
+          const restoreNames = [...state.toolDenylist];
+          Object.assign(state, next);
+          applyToolDenylist(pi, state, restoreNames, restorableToolNames);
+          saveState(pi, ctx, state);
+        },
+      });
     },
   });
 
@@ -309,6 +353,9 @@ export default function sessionCapabilities(pi: ExtensionAPI): void {
       event.reason !== "new" && state ? baselineFromState(state) : captureToolBaseline(pi);
     addActiveToolsToBaseline(pi, toolBaseline);
     state ??= initialSessionCapabilityState(toolBaseline);
+    if (shouldApplyDefault(ctx, event.reason, currentEntryState)) {
+      state = applyDefaultProfile(state, ctx, options.homeDir);
+    }
     const toolStateChanged = reconcileToolInventory(pi, state).changed;
     sessionCapabilityState.set(ctx.sessionManager.getSessionId(), state);
     applyToolDenylist(pi, state, state.toolEnabledNames ?? [], restorableToolNames);
@@ -323,6 +370,7 @@ export default function sessionCapabilities(pi: ExtensionAPI): void {
     const state = currentSessionState(ctx);
     if (!state) return;
     observeNewTools(pi, state, knownToolNames, restorableToolNames);
+    if (reconcileToolInventory(pi, state).changed) saveState(pi, ctx, state);
     applyToolDenylist(pi, state, state.toolEnabledNames ?? [], restorableToolNames);
   });
 
@@ -330,6 +378,7 @@ export default function sessionCapabilities(pi: ExtensionAPI): void {
     const state = currentSessionState(ctx);
     if (!state) return;
     observeNewTools(pi, state, knownToolNames, restorableToolNames);
+    if (reconcileToolInventory(pi, state).changed) saveState(pi, ctx, state);
     applyToolDenylist(pi, state, state.toolEnabledNames ?? [], restorableToolNames);
   });
 

package/src/session-capability-profile-store.ts

@@ -0,0 +1,176 @@
+import { readFileSync } from "node:fs";
+import { getSupiConfigPath, replaceSupiConfigSection } from "@mrclrchtr/supi-core/config";
+import {
+  isSessionCapabilityProfileId,
+  resolveSessionCapabilityProfiles,
+  type SessionCapabilityProfileDiagnostic,
+  type SessionCapabilityProfileScope,
+  type SessionCapabilityProfilesResolution,
+  validateSessionCapabilityProfile,
+} from "@mrclrchtr/supi-core/session";
+
+const SECTION = "sessionCapabilities";
+
+/** Config locations and the current project trust decision. */
+export interface CapabilityProfileStoreOptions {
+  cwd: string;
+  /** Override the OS home directory for global configuration. */
+  homeDir?: string;
+  /** Get the current trust decision before project access. */
+  isProjectTrusted: () => boolean;
+}
+
+/** Resolved profiles and the raw default values for scoped actions. */
+export interface CapabilityProfileCatalog extends SessionCapabilityProfilesResolution {
+  defaultValues: { global?: unknown; project?: unknown };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Read strictly so malformed JSON cannot be treated as an absent config file. */
+function readSection(path: string): unknown {
+  try {
+    const config: unknown = JSON.parse(readFileSync(path, "utf-8"));
+    if (!isRecord(config)) throw new Error("Config root must be an object.");
+    return config[SECTION];
+  } catch (error) {
+    if (isRecord(error) && error.code === "ENOENT") return undefined;
+    throw new Error(
+      `Cannot read config at ${path}: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error },
+    );
+  }
+}
+
+function readCatalogSection(
+  path: string,
+  scope: SessionCapabilityProfileScope,
+  errors: SessionCapabilityProfileDiagnostic[],
+): unknown {
+  try {
+    return readSection(path);
+  } catch (error) {
+    errors.push({ scope, path, message: error instanceof Error ? error.message : String(error) });
+    // A failed read is invalid, not absent. It must block default inheritance.
+    return null;
+  }
+}
+
+function readWritableSection(
+  scope: SessionCapabilityProfileScope,
+  options: CapabilityProfileStoreOptions,
+): Record<string, unknown> {
+  if (scope === "project" && !options.isProjectTrusted()) {
+    throw new Error("Project trust is required to change capability profiles.");
+  }
+  const path = getSupiConfigPath(scope, options.cwd, options);
+  const section = readSection(path);
+  if (section === undefined) return {};
+  if (!isRecord(section)) throw new Error(`sessionCapabilities must be an object: ${path}`);
+  if (Object.hasOwn(section, "profiles") && !isRecord(section.profiles)) {
+    throw new Error(`profiles must be an object: ${path}`);
+  }
+  return section;
+}
+
+/** Check section removal because the shared writer ignores file-removal errors. */
+function writeSection(
+  scope: SessionCapabilityProfileScope,
+  section: Record<string, unknown>,
+  options: CapabilityProfileStoreOptions,
+): void {
+  replaceSupiConfigSection({ section: SECTION, scope, cwd: options.cwd }, section, options);
+  if (Object.keys(section).length === 0) {
+    const path = getSupiConfigPath(scope, options.cwd, options);
+    if (readSection(path) !== undefined) throw new Error(`Cannot remove ${SECTION} at ${path}.`);
+  }
+}
+
+/**
+ * Read and change scoped configuration without a cache or changes to session state.
+ * Read errors become diagnostics. Mutation errors are thrown to the caller.
+ */
+export function createCapabilityProfileStore(options: CapabilityProfileStoreOptions) {
+  const store = {
+    /** Read current profiles and diagnostics. Ignore untrusted project configuration. */
+    read(): CapabilityProfileCatalog {
+      const projectTrusted = options.isProjectTrusted();
+      const readErrors: SessionCapabilityProfileDiagnostic[] = [];
+      const global = readCatalogSection(
+        getSupiConfigPath("global", options.cwd, options),
+        "global",
+        readErrors,
+      );
+      const project = projectTrusted
+        ? readCatalogSection(
+            getSupiConfigPath("project", options.cwd, options),
+            "project",
+            readErrors,
+          )
+        : undefined;
+      const resolution = resolveSessionCapabilityProfiles({ global, project, projectTrusted });
+      return {
+        ...resolution,
+        errors: [
+          ...readErrors,
+          ...resolution.errors.filter(
+            (error) => !readErrors.some((read) => read.scope === error.scope),
+          ),
+        ],
+        defaultValues: {
+          ...(isRecord(global) && Object.hasOwn(global, "defaultProfile")
+            ? { global: global.defaultProfile }
+            : {}),
+          ...(isRecord(project) && Object.hasOwn(project, "defaultProfile")
+            ? { project: project.defaultProfile }
+            : {}),
+        },
+      };
+    },
+    /** Save exact exclusion sets. Replacement requires explicit approval from the caller. */
+    save(
+      scope: SessionCapabilityProfileScope,
+      id: string,
+      profile: unknown,
+      replace = false,
+    ): void {
+      if (!isSessionCapabilityProfileId(id)) {
+        throw new Error("Invalid profile ID: use lowercase words with single hyphens.");
+      }
+      const result = validateSessionCapabilityProfile(profile);
+      if (!result.profile) throw new Error(result.errors.join(" "));
+      const section = readWritableSection(scope, options);
+      const profiles = isRecord(section.profiles) ? section.profiles : {};
+      if (Object.hasOwn(profiles, id) && replace !== true) {
+        throw new Error(`Profile ${id} already exists in ${scope}. Confirm replacement first.`);
+      }
+      section.profiles = { ...profiles, [id]: result.profile };
+      writeSection(scope, section, options);
+    },
+    /** Delete one scoped definition. Leave all default references unchanged. */
+    delete(scope: SessionCapabilityProfileScope, id: string): void {
+      const section = readWritableSection(scope, options);
+      if (!isRecord(section.profiles) || !Object.hasOwn(section.profiles, id)) return;
+      delete section.profiles[id];
+      if (Object.keys(section.profiles).length === 0) delete section.profiles;
+      writeSection(scope, section, options);
+    },
+    /** Set a default ID, store null for none, or remove the key with undefined. */
+    setDefault(scope: SessionCapabilityProfileScope, id: string | null | undefined): void {
+      const section = readWritableSection(scope, options);
+      if (
+        id !== undefined &&
+        id !== null &&
+        !store.read().effectiveProfiles.some((profile) => profile.id === id)
+      ) {
+        throw new Error(`Default profile ${id} is missing or invalid.`);
+      }
+      if (id === undefined) delete section.defaultProfile;
+      else section.defaultProfile = id;
+      writeSection(scope, section, options);
+    },
+  };
+  return store;
+}