pi-profile-switch 0.3.1 → 0.4.2

package/src/switching/activate-profile.ts

@@ -1,144 +0,0 @@
-/**
- * SwitchProfile: the in-session activation orchestrator (ADR-0007).
- *
- * There is no reload and no generated-settings rewrite. Activating a profile
- * means: resolve it against Pi's live resources, apply the runtime parts
- * (model, tools, MCP allowlist), and remember the choice. Skills and
- * instructions need no action here — they are applied by the next
- * `before_agent_start` from the returned selection.
- *
- * Flow:
- *   1. load the catalog (project entries only when Pi reports the project
- *      trusted) and resolve the name — unknown names fail with candidates
- *   2. resolve the selection against the live resources; a declared MCP
- *      intent that cannot be satisfied fails here
- *   3. validate the model preset (exists, has auth) — still nothing applied
- *   4. persist the choice to the target profile's scope state file
- *   5. apply model/thinking/tools/MCP; a failure reports loudly
- *
- * Startup activation passes `persist: false` (the flag selection must not
- * overwrite the saved one) and `overlay: null` (a stored overlay never
- * outlives its runtime).
- */
-
-import { ProfileCatalog } from "../profile-catalog.ts";
-import { decidePreset, type SessionChoices } from "../model-selection.ts";
-import { resolveSelection, type LiveResources, type ResolvedSelection } from "../profile-resolver.ts";
-import type { ExplicitDeclarations } from "../startup-selection.ts";
-import { RuntimeStateStore, stateDirFor, type RuntimeOverlay } from "../runtime-state-store.ts";
-import { applySelection, validateSelection, type ApplySurface } from "./apply-profile.ts";
-
-export class ActivationError extends Error {
-	constructor(message: string) {
-		super(message);
-		this.name = "ActivationError";
-	}
-}
-
-export interface ActivationDeps {
-	/** The user's real agent dir (e.g. ~/.pi/agent). */
-	agentDir: string;
-	/** The project working directory. */
-	cwd: string;
-	/** Pi's trust decision for `cwd` (`ctx.isProjectTrusted()`). */
-	projectTrusted: boolean;
-	/** The live resource view loaded by the caller. */
-	live: LiveResources;
-	/** The narrow Pi surface the selection is applied to. */
-	surface: ApplySurface;
-	/** Inputs for the model-preset precedence decision (decided after the
-	 *  profile resolves, since it depends on the declared model). */
-	presetInputs: { explicit: ExplicitDeclarations; session: SessionChoices; force: boolean };
-}
-
-export interface ActivationResult {
-	selection: ResolvedSelection;
-	/** The overlay this activation applied; absent when the runtime runs the
-	 *  profile exactly as it is declared. Callers surface it (the footer badge)
-	 *  instead of re-reading the state file. */
-	overlay?: RuntimeOverlay;
-}
-
-/** Resolves a profile against the live resources without applying it.
- *  Throws ActivationError for unknown names and SelectionError for declared
- *  MCP intents that cannot be satisfied. A CLI-declared
- *  `--tools`/`--exclude-tools` suppresses the profile's tool selection
- *  unless the user made an explicit `/profile use` choice. */
-export async function resolveProfileSelection(
-	name: string,
-	deps: Pick<ActivationDeps, "agentDir" | "cwd" | "projectTrusted" | "live" | "presetInputs">,
-	overlay?: RuntimeOverlay,
-): Promise<ResolvedSelection> {
-	const catalog = await ProfileCatalog.load(deps.agentDir, {
-		projectDir: deps.projectTrusted ? deps.cwd : undefined,
-	});
-	const profile = catalog.resolve(name);
-	if (profile === undefined) {
-		throw new ActivationError(
-			`unknown profile ${JSON.stringify(name)} — available: [${catalog.list().map((entry) => entry.name).join(", ")}]`,
-		);
-	}
-	const suppressTools = !deps.presetInputs.force && deps.presetInputs.explicit.tools;
-	return resolveSelection({ profile, overlay, live: deps.live, suppressTools });
-}
-
-/** Drops a stale saved selection from the scope that no longer owns it. A
- *  project state file left behind by a previous project profile shadows the
- *  new global choice on the next startup (project state wins), so the switch
- *  path clears it; the scope's overlay stays, because that belongs to the
- *  profile it was created for. */
-async function clearOtherSelection(stateDir: string): Promise<void> {
-	const store = new RuntimeStateStore(stateDir);
-	if ((await store.read()).activeProfile !== undefined) {
-		await store.update({ otherActiveProfile: undefined });
-	}
-}
-
-/** Activates a profile: resolve, validate, optionally persist, apply. */
-export async function activateProfile(
-	name: string,
-	deps: ActivationDeps,
-	options?: { overlay?: RuntimeOverlay | null; persist?: boolean },
-): Promise<ActivationResult> {
-	const overlay = options?.overlay ?? undefined;
-	const selection = await resolveProfileSelection(name, deps, overlay);
-	const preset = decidePreset({ model: selection.model, ...deps.presetInputs });
-
-	// Validate before touching anything: the model preset is the only
-	// fallible runtime step.
-	const validationError = validateSelection(selection, deps.surface, preset);
-	if (validationError !== undefined) {
-		throw new ActivationError(validationError);
-	}
-
-	if (options?.persist !== false) {
-		// Exactly one scope holds the saved selection: the project state file
-		// for a project profile, the global one otherwise (including the
-		// built-in `default`). A project profile is only reachable in a
-		// trusted project, so an untrusted project is skipped exactly like
-		// its catalog read — its state file stays untouched (ADR-0007).
-		const ownDir = stateDirFor(selection.source, deps);
-		const projectDir = stateDirFor("project", deps);
-		const writable = selection.source !== "project" || deps.projectTrusted;
-		if (writable) {
-			await new RuntimeStateStore(ownDir).update({
-				activeProfile: selection.name,
-				overlay: overlay ?? undefined,
-			});
-			// The scope that owned the previous selection must let go of it,
-			// or the next startup restores it: project state wins over global.
-			// An untrusted project is never read or written here either.
-			const otherDir = selection.source === "project" ? stateDirFor("global", deps) : projectDir;
-			if (otherDir !== ownDir && (otherDir !== projectDir || deps.projectTrusted)) {
-				await clearOtherSelection(otherDir);
-			}
-		}
-	}
-
-	const result = await applySelection({ selection, surface: deps.surface, preset });
-	if (!result.applied) {
-		throw new ActivationError(result.error ?? `profile "${name}" could not be applied`);
-	}
-
-	return { selection, ...(overlay === undefined ? {} : { overlay }) };
-}

package/src/switching/apply-profile.ts

@@ -1,131 +0,0 @@
-/**
- * ApplyProfile: applies a resolved selection to the running Pi.
- *
- * Replaces the launch-plan application of the host architecture: there is no
- * plan file and no reload. Application is ordered so that the only
- * fallible step — the model preset — runs first; a failure leaves the
- * runtime untouched and the caller keeps the previous state.
- *
- * Steps:
- *   1. validate: the declared model exists and has configured auth.
- *   2. model: `setModel` + `setThinkingLevel` (when the preset applies).
- *   3. tools: `setActiveTools` with the resolved active set. Literals the
- *      live registry does not provide yet stay in `pendingTools` and are
- *      retried by the caller each turn (MCP and extension tools register
- *      after session start).
- *   4. mcp: publish the runtime server allowlist to pi-mcp-adapter.
- *
- * Dependency-injected against a narrow surface so unit tests never need a
- * real Pi.
- */
-
-import {
-	MCP_ALLOWLIST_EVENT,
-	MCP_ALLOWLIST_VERSION,
-} from "../mcp-coordination.ts";
-import type { PresetDecisions } from "../model-selection.ts";
-import type { ResolvedSelection } from "../profile-resolver.ts";
-
-/** The narrow slice of ExtensionAPI/Context the application needs. */
-export interface ApplySurface {
-	getAllTools(): Array<{ name: string }>;
-	setActiveTools(names: string[]): void;
-	modelRegistry: {
-		find(provider: string, id: string): unknown | undefined;
-		hasConfiguredAuth(model: unknown): boolean;
-	};
-	setModel(model: unknown): Promise<boolean>;
-	setThinkingLevel(level: string): void;
-	events: { emit(channel: string, data: unknown): void };
-}
-
-export interface ApplyResult {
-	applied: boolean;
-	/** Present when nothing was applied. */
-	error?: string;
-	warnings: string[];
-	/** Tool literals still missing from the live registry. */
-	pendingTools: string[];
-}
-
-/** Checks everything that can be checked before mutating the runtime. */
-export function validateSelection(
-	selection: ResolvedSelection,
-	surface: ApplySurface,
-	preset: PresetDecisions,
-): string | undefined {
-	if (selection.model === undefined || !preset.model) return undefined;
-	const model = surface.modelRegistry.find(selection.model.provider, selection.model.id);
-	if (model === undefined) {
-		return `profile "${selection.name}": declared model ${selection.model.provider}/${selection.model.id} not found`;
-	}
-	if (!surface.modelRegistry.hasConfiguredAuth(model)) {
-		return `profile "${selection.name}": model ${selection.model.provider}/${selection.model.id} has no configured auth`;
-	}
-	return undefined;
-}
-
-/** Applies the selection. Validation runs first; on failure nothing is
- *  applied and the runtime keeps its previous state. */
-export async function applySelection(input: {
-	selection: ResolvedSelection;
-	surface: ApplySurface;
-	preset: PresetDecisions;
-}): Promise<ApplyResult> {
-	const { selection, surface, preset } = input;
-	const error = validateSelection(selection, surface, preset);
-	if (error !== undefined) {
-		return { applied: false, error, warnings: [], pendingTools: [] };
-	}
-
-	if (selection.model !== undefined && preset.model) {
-		const model = surface.modelRegistry.find(selection.model.provider, selection.model.id);
-		const applied = await surface.setModel(model);
-		if (!applied) {
-			return {
-				applied: false,
-				error: `profile "${selection.name}": model ${selection.model.provider}/${selection.model.id} could not be activated`,
-				warnings: [],
-				pendingTools: [],
-			};
-		}
-		if (selection.model.thinkingLevel !== undefined && preset.thinking) {
-			surface.setThinkingLevel(selection.model.thinkingLevel);
-		}
-	}
-
-	if (selection.tools !== undefined) {
-		surface.setActiveTools(selection.tools);
-	}
-
-	if (selection.mcp !== undefined) {
-		surface.events.emit(MCP_ALLOWLIST_EVENT, {
-			version: MCP_ALLOWLIST_VERSION,
-			profile: selection.name,
-			servers: selection.mcp,
-		});
-	}
-
-	return { applied: true, warnings: [], pendingTools: selection.pendingTools };
-}
-
-/** Retries pending tool literals against the live registry. Once every
- *  literal resolves the caller stops retrying, so a user's later native tool
- *  toggle is never clobbered. */
-export function retryPendingTools(input: {
-	selection: ResolvedSelection;
-	surface: ApplySurface;
-}): { pendingTools: string[]; active?: string[]; applied: boolean } {
-	const { selection, surface } = input;
-	if (selection.pendingTools.length === 0) {
-		return { pendingTools: [], applied: false };
-	}
-	const live = new Set(surface.getAllTools().map((tool) => tool.name));
-	const resolved = selection.pendingTools.filter((name) => live.has(name));
-	if (resolved.length === 0) {
-		return { pendingTools: selection.pendingTools, applied: false };
-	}
-	const active = [...new Set([...(selection.tools ?? []), ...resolved])];
-	surface.setActiveTools(active);
-	return { pendingTools: selection.pendingTools.filter((name) => !live.has(name)), active, applied: true };
-}