@mrclrchtr/supi-skills 7.2.0 → 7.3.0

package/src/skill-settings.ts

@@ -1,398 +1,91 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import {
-  DefaultPackageManager,
-  type ExtensionAPI,
-  type ExtensionContext,
-  getAgentDir,
-  type ResolvedResource,
-  SettingsManager,
-} from "@earendil-works/pi-coding-agent";
-import {
-  registerSettings,
-  type ScopedFieldValue,
-  type SettingsAction,
-  type SettingsApplyResult,
-  type SettingsContext,
-  type SettingsModule,
-  type SettingsScope,
-  type ValueSource,
-} from "@mrclrchtr/supi-core/settings";
-import {
-  buildSkillCatalog,
-  mergeRuntimeSkills,
-  type SkillCatalog,
-  type SkillRecord,
-  skillSourceIdentity,
-} from "./skill-catalog.ts";
-import {
-  hasExactSkillLoadOverride,
-  type SkillLoadOverride,
-  updateSkillLoadOverrides,
-} from "./skill-load-settings.ts";
-import {
-  applyPromptOverrides,
-  DISABLED,
-  ENABLED,
-  MODEL_DISABLED,
-  notifyInvocationConfigWarnings,
-  persistInvocation,
-  resolveInvocation,
-} from "./skill-model-invocation.ts";
+  registerSessionCapabilitySkillProvider,
+  sessionCapabilityState,
+} from "@mrclrchtr/supi-core/session";
+import { registerSettings, type SettingsModule } from "@mrclrchtr/supi-core/settings";
+import { applyPromptOverrides, notifyInvocationConfigWarnings } from "./skill-model-invocation.ts";
+import { SkillSettingsController, type SkillSettingsOptions } from "./skill-settings-controller.ts";
 
 const SETTINGS_SECTION_ID = "skills";
-interface SkillSettingsOptions {
-  agentDir?: string;
-  homeDir?: string;
-}
-interface SkillSettingsControllerOptions {
-  cwd: string;
-  agentDir: string;
-  homeDir?: string;
-  projectTrusted: boolean;
-  settingsManager: SettingsManager;
-  globalSettingsManager: SettingsManager;
-}
-
-function recordResources(record: SkillRecord): ResolvedResource[] {
-  return record.sources.flatMap((source) => (source.resource ? [source.resource] : []));
-}
-function isLoaded(record: SkillRecord): boolean {
-  return (
-    record.activeSkill !== undefined ||
-    record.sources.some((source) => source.runtime || source.resource?.enabled)
-  );
-}
-function canDisable(record: SkillRecord): boolean {
-  return record.sources.length > 0 && record.sources.every((source) => !source.runtime);
-}
-
-function sourceDefault(record: SkillRecord): boolean {
-  const winner =
-    record.activeSkill ??
-    record.sources.find((source) => source.runtime || source.resource?.enabled)?.skill ??
-    record.sources[0]?.skill;
-  return winner?.disableModelInvocation ?? false;
-}
-
-function moreSpecificSource(left: ValueSource, right: ValueSource): ValueSource {
-  const rank: Record<ValueSource, number> = { default: 0, global: 1, project: 2 };
-  return rank[left] >= rank[right] ? left : right;
-}
-
-function displayValue(value: string, source: ValueSource): string {
-  return `${value} (${source})`;
-}
+type SkillControllerGetter = (
+  cwd: string,
+  projectTrusted: boolean,
+) => Promise<SkillSettingsController>;
 
-function validateAction(record: SkillRecord, action: SettingsAction): void {
-  if (action.kind !== "set") return;
-  if (![ENABLED, MODEL_DISABLED, DISABLED].includes(action.value)) {
-    throw new Error(`Invalid skill state: "${action.value}"`);
-  }
-  if (action.value === DISABLED && !canDisable(record)) {
-    throw new Error(`Full disable is unavailable for skill "${record.name}"`);
-  }
-}
-
-function loadOverride(
-  record: SkillRecord,
-  action: SettingsAction,
-  hasExactOverride: boolean,
-): SkillLoadOverride | undefined {
-  if (action.kind === "unset") return hasExactOverride ? "inherit" : undefined;
-  if (action.value === DISABLED) return "unload";
-  return isLoaded(record) ? undefined : "load";
-}
-
-class SkillSettingsController {
-  private readonly cwd: string;
-  private readonly agentDir: string;
-  private readonly homeDir: string | undefined;
-  private readonly projectTrusted: boolean;
-  private readonly settingsManager: SettingsManager;
-  private readonly globalSettingsManager: SettingsManager;
-  private readonly pendingDisabled = new Map<string, Set<string>>();
-  private globalCatalog: SkillCatalog = new Map();
-  private projectCatalog: SkillCatalog = new Map();
-
-  private constructor(options: SkillSettingsControllerOptions) {
-    this.cwd = options.cwd;
-    this.agentDir = options.agentDir;
-    this.homeDir = options.homeDir;
-    this.projectTrusted = options.projectTrusted;
-    this.settingsManager = options.settingsManager;
-    this.globalSettingsManager = options.globalSettingsManager;
-  }
-
-  static async create(
-    cwd: string,
-    projectTrusted: boolean,
-    options: SkillSettingsOptions,
-  ): Promise<SkillSettingsController> {
-    const agentDir = options.agentDir ?? getAgentDir();
-    const controller = new SkillSettingsController({
-      cwd,
-      agentDir,
-      homeDir: options.homeDir,
-      projectTrusted,
-      settingsManager: SettingsManager.create(cwd, agentDir, { projectTrusted }),
-      globalSettingsManager: SettingsManager.create(cwd, agentDir, { projectTrusted: false }),
-    });
-    await controller.refreshCatalogs();
-    return controller;
-  }
-
-  private async refreshCatalogs(): Promise<void> {
-    await Promise.all([this.settingsManager.reload(), this.globalSettingsManager.reload()]);
-    const [globalPaths, projectPaths] = await Promise.all([
-      new DefaultPackageManager({
-        cwd: this.cwd,
-        agentDir: this.agentDir,
-        settingsManager: this.globalSettingsManager,
-      }).resolve(async () => "skip"),
-      new DefaultPackageManager({
-        cwd: this.cwd,
-        agentDir: this.agentDir,
-        settingsManager: this.settingsManager,
-      }).resolve(async () => "skip"),
-    ]);
-    this.globalCatalog = buildSkillCatalog(globalPaths.skills, this.cwd, this.agentDir);
-    this.projectCatalog = buildSkillCatalog(projectPaths.skills, this.cwd, this.agentDir);
-  }
-
-  private records(scope: SettingsScope, ctx?: ExtensionContext): SkillCatalog {
-    return mergeRuntimeSkills(
-      scope === "project" ? this.projectCatalog : this.globalCatalog,
-      ctx,
-      scope,
-      this.pendingDisabled,
-    );
-  }
-
-  /**
-   * Prefer original global provenance when a project support path resolves the
-   * same file as a project resource. This lets Unset remove both the exact
-   * override and the generated support path after a catalog refresh.
-   */
-  private actionResources(record: SkillRecord, scope: SettingsScope): ResolvedResource[] {
-    const globalResources =
-      scope === "project" ? recordResources(this.globalCatalog.get(record.name) ?? record) : [];
-    const unique = new Map<string, ResolvedResource>();
-    for (const resource of [...globalResources, ...recordResources(record)]) {
-      const key = `${resource.path}\0${resource.metadata.origin}\0${resource.metadata.source}`;
-      if (!unique.has(key)) unique.set(key, resource);
-    }
-    return Array.from(unique.values());
-  }
-
-  /**
-   * Attribute the effective load value to the narrowest scoped override.
-   * Project resources can be support-path surrogates, so attribution compares
-   * their effective load state with the original global catalog.
-   */
-  private loadSource(record: SkillRecord, scope: SettingsScope): ValueSource {
-    const resources = recordResources(record);
-    const exact = hasExactSkillLoadOverride({
-      settingsManager: this.settingsManager,
-      resources,
-      scope,
-      cwd: this.cwd,
-      agentDir: this.agentDir,
-    });
-    if (exact) return scope;
-    if (scope === "global") {
-      return resources.some((resource) => !resource.enabled) ? "global" : "default";
-    }
-    if (resources.some((resource) => resource.metadata.scope === "project" && !resource.enabled)) {
-      return "project";
-    }
-    const globalRecord = this.globalCatalog.get(record.name);
-    if (!globalRecord) return "default";
-    const globalResources = recordResources(globalRecord);
-    const projectLoaded = resources.some((resource) => resource.enabled);
-    const globalLoaded = globalResources.some((resource) => resource.enabled);
-    if (projectLoaded !== globalLoaded) return "project";
-    return this.loadSource(globalRecord, "global");
-  }
-
-  private rowSource(
-    record: SkillRecord,
-    scope: SettingsScope,
-    invocationSource: ValueSource,
-  ): ValueSource {
-    return moreSpecificSource(this.loadSource(record, scope), invocationSource);
-  }
-
-  private row(record: SkillRecord, scope: SettingsScope): ScopedFieldValue {
-    const invocation = resolveInvocation({
-      name: record.name,
-      sourceDefault: sourceDefault(record),
-      scope,
-      cwd: this.cwd,
-      projectTrusted: this.projectTrusted,
-      homeDir: this.homeDir,
-    });
-    const value = !isLoaded(record) ? DISABLED : invocation.disabled ? MODEL_DISABLED : ENABLED;
-    const source = this.rowSource(record, scope, invocation.source);
-    const values = canDisable(record)
-      ? [ENABLED, MODEL_DISABLED, DISABLED]
-      : [ENABLED, MODEL_DISABLED];
-    const sourceCount = record.sources.length;
-    const limitation = canDisable(record)
-      ? ""
-      : " Full disable is unavailable because PI does not expose a load setting for one or more sources.";
-    return {
-      field: {
-        kind: "enum",
-        key: record.name,
-        label: record.name,
-        values,
-        description: `${record.description}${sourceCount > 1 ? ` ${sourceCount} sources.` : ""}${limitation}`,
-      },
-      displayValue: displayValue(value, source),
-      editValue: value,
-      source,
-      ...(scope === "project" && source === "project"
-        ? {
-            inheritanceSource:
-              this.globalRowSource(record.name) === "global" ? "global" : "default",
-          }
-        : {}),
-    };
-  }
-
-  private globalRowSource(name: string): ValueSource {
-    const record = this.globalCatalog.get(name);
-    if (!record) return "default";
-    const invocation = resolveInvocation({
-      name,
-      sourceDefault: sourceDefault(record),
-      scope: "global",
-      cwd: this.cwd,
-      projectTrusted: false,
-      homeDir: this.homeDir,
-    });
-    return this.rowSource(record, "global", invocation.source);
-  }
-
-  read(scope: SettingsScope, ctx?: ExtensionContext): ScopedFieldValue[] {
-    return Array.from(this.records(scope, ctx).values())
-      .sort((left, right) => left.name.localeCompare(right.name))
-      .map((record) => this.row(record, scope));
-  }
-
-  private updatePendingDisabled(
-    fieldKey: string,
-    nextLoadOverride: SkillLoadOverride,
-    activeSkillIdentity: string | undefined,
-  ): void {
-    if (nextLoadOverride !== "unload") {
-      this.pendingDisabled.delete(fieldKey);
-      return;
-    }
-    if (activeSkillIdentity) {
-      this.pendingDisabled.set(fieldKey, new Set([activeSkillIdentity]));
-    }
-  }
-
-  async apply(
-    scope: SettingsScope,
-    fieldKey: string,
-    action: SettingsAction,
-    ctx?: ExtensionContext,
-  ): Promise<SettingsApplyResult> {
-    if (scope === "project" && !this.projectTrusted) {
-      throw new Error("Project is not trusted; refusing to write project skill settings");
-    }
-    const record = this.records(scope, ctx).get(fieldKey);
-    if (!record) return {};
-    validateAction(record, action);
-    const activeSkillIdentity = record.activeSkill
-      ? skillSourceIdentity(record.activeSkill)
-      : undefined;
-
-    if (action.kind !== "set" || action.value !== DISABLED) {
-      persistInvocation({
-        name: fieldKey,
-        disabled: action.kind === "set" ? action.value === MODEL_DISABLED : undefined,
-        scope,
-        cwd: this.cwd,
-        homeDir: this.homeDir,
-      });
-    }
-
-    const resources = this.actionResources(record, scope);
-    const hasLoadOverride = hasExactSkillLoadOverride({
-      settingsManager: this.settingsManager,
-      resources,
-      scope,
-      cwd: this.cwd,
-      agentDir: this.agentDir,
-    });
-    const nextLoadOverride = loadOverride(record, action, hasLoadOverride);
-    if (nextLoadOverride && resources.length > 0) {
-      updateSkillLoadOverrides({
-        settingsManager: this.settingsManager,
-        resources,
-        scope,
-        state: nextLoadOverride,
-        cwd: this.cwd,
-        agentDir: this.agentDir,
-      });
-      await this.settingsManager.flush();
-      const error = this.settingsManager.drainErrors()[0];
-      await this.refreshCatalogs();
-      if (error) throw error.error;
-      this.updatePendingDisabled(fieldKey, nextLoadOverride, activeSkillIdentity);
-      return {
-        notice: { message: "Reload required for skill load changes", level: "info" },
-      };
-    }
-    return {};
-  }
-}
-
-function createSkillSettingsModule(options: SkillSettingsOptions): SettingsModule {
+function createSkillControllerGetter(options: SkillSettingsOptions): SkillControllerGetter {
   let controllerKey: string | undefined;
   let controllerPromise: Promise<SkillSettingsController> | undefined;
-
-  const getController = (context: SettingsContext): Promise<SkillSettingsController> => {
-    const projectTrusted = context.ctx?.isProjectTrusted() ?? false;
-    const key = `${context.cwd}\0${projectTrusted}`;
+  return (cwd, projectTrusted) => {
+    const key = `${cwd}\0${projectTrusted}`;
     if (!controllerPromise || controllerKey !== key) {
       controllerKey = key;
-      controllerPromise = SkillSettingsController.create(context.cwd, projectTrusted, options);
+      controllerPromise = SkillSettingsController.create(cwd, projectTrusted, options);
     }
     return controllerPromise;
   };
+}
 
+function createSkillSettingsModule(
+  options: SkillSettingsOptions,
+  getController: SkillControllerGetter,
+): SettingsModule {
   return {
     id: SETTINGS_SECTION_ID,
     label: "Skills",
     read: async (context) => {
       if (context.ctx) notifyInvocationConfigWarnings(context.ctx, options.homeDir);
-      return { rows: (await getController(context)).read(context.scope, context.ctx) };
+      const projectTrusted = context.ctx?.isProjectTrusted() ?? false;
+      return {
+        rows: (await getController(context.cwd, projectTrusted)).read(context.scope, context.ctx),
+      };
     },
-    apply: async (request) =>
-      (await getController(request)).apply(
+    apply: async (request) => {
+      const projectTrusted = request.ctx?.isProjectTrusted() ?? false;
+      return (await getController(request.cwd, projectTrusted)).apply(
         request.scope,
         request.fieldKey,
         request.action,
         request.ctx,
-      ),
+      );
+    },
   };
 }
 
 /** Register scoped skill availability settings and prompt overrides. */
 export default function skillSettings(pi: ExtensionAPI, options: SkillSettingsOptions = {}): void {
-  registerSettings(pi, createSkillSettingsModule(options));
+  const getController = createSkillControllerGetter(options);
+  const providerDisposers = new Map<string, () => void>();
+  registerSettings(pi, createSkillSettingsModule(options, getController));
+
+  pi.on("session_start", (_event, ctx) => {
+    const sessionId = ctx.sessionManager.getSessionId();
+    providerDisposers.get(sessionId)?.();
+    const dispose = registerSessionCapabilitySkillProvider<ExtensionCommandContext>(sessionId, {
+      listEligibleSkills: async (commandCtx) => {
+        const controller = await getController(commandCtx.cwd, commandCtx.isProjectTrusted());
+        return controller.eligibleModelSkills(commandCtx);
+      },
+    });
+    providerDisposers.set(sessionId, dispose);
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    const sessionId = ctx.sessionManager.getSessionId();
+    providerDisposers.get(sessionId)?.();
+    providerDisposers.delete(sessionId);
+  });
 
   pi.on("before_agent_start", (event, ctx) => {
     notifyInvocationConfigWarnings(ctx, options.homeDir);
+    const state = sessionCapabilityState.get(ctx.sessionManager.getSessionId());
     const systemPrompt = applyPromptOverrides({
       options: event.systemPromptOptions,
       systemPrompt: event.systemPrompt,
       cwd: ctx.cwd,
       projectTrusted: ctx.isProjectTrusted(),
       homeDir: options.homeDir,
+      hiddenSkillNames: new Set(state?.hiddenSkillNames ?? []),
     });
     return systemPrompt === undefined ? undefined : { systemPrompt };
   });