pi-profile-switch 0.3.1 → 0.4.2

package/src/profile-catalog.ts

@@ -1,23 +1,7 @@
 /**
  * ProfileCatalog: reads profile definitions from the global catalog
- * (`<agentDir>/profiles.json`) and, for trusted projects, the project
- * catalog (`<projectDir>/.pi/profiles.json`).
- *
- * ADR-0007 semantics:
- * - A profile references skills, MCP servers, and tools, and may declare
- *   instructions and a model preset. Extensions are not a profile resource:
- *   every installed extension loads natively in every profile.
- * - schemaVersion 1 is the only accepted version: any other value fails
- *   loudly instead of guessing at a shape.
- * - Unknown fields (an `extensions` declaration left over from v0.1.0, an
- *   inheritance key) are ignored silently; saving drops them, so a written
- *   definition always matches the current shape.
- * - The catalog key for MCP servers is `mcps` (plural, like `skills` and
- *   `tools`). The legacy name `mcp` is still READ as an alias so an
- *   existing catalog keeps its allowlist; `mcps` wins when both keys are
- *   present, and a value of the wrong type fails loudly either way.
- *   Definitions always carry the canonical `mcps` field in memory, and
- *   profile-catalog-store.ts drops a file's legacy key on its next write.
+ * (`~/.pi-profile-switch/profiles.json`, legacy fallback `<agentDir>/profiles.json`)
+ * and, for trusted projects, the project catalog (`<projectDir>/.pi/profiles.json`).
  *
  * Invariants:
  * - The built-in `default` profile never exists in either file and cannot be
@@ -25,14 +9,15 @@
  * - A project profile with the same name fully replaces the global
  *   definition (no merge, no inheritance); removing the project entry
  *   immediately reveals the global one.
- * - The caller passes `projectDir` only when Pi reports the project trusted —
- *   an untrusted project's catalog is never read.
+ * - The caller passes `projectDir` only when the resolver's trust check
+ *   passed — an untrusted project's catalog is never read.
  * - A malformed catalog fails loudly (CatalogError) rather than silently
- *   starting with an unintended selection.
+ *   starting unfiltered.
  */
 
 import path from "node:path";
 
+import { resolveGlobalProfilesPath } from "./workspace.ts";
 import { isRecord, readJsonFile } from "./json-file.ts";
 
 export const PROFILE_SCHEMA_VERSION = 1;
@@ -45,14 +30,19 @@ export interface ProfileModel {
 }
 
 /** A profile definition as stored in a catalog file. All fields optional:
- *  undeclared fields leave Pi's behavior untouched. */
+ *  undeclared fields leave Pi's behavior untouched (PRD default-first rule).
+ *  Model fields mirror Pi's settings.json keys (defaultProvider/defaultModel/
+ *  defaultThinkingLevel) for direct compatibility. */
 export interface ProfileDefinition {
 	label?: string;
 	description?: string;
 	skills?: string[];
+	extensions?: string[];
 	mcps?: string[];
 	tools?: string[];
-	model?: ProfileModel;
+	defaultProvider?: string;
+	defaultModel?: string;
+	defaultThinkingLevel?: string;
 	instructions?: string;
 }
 
@@ -85,27 +75,6 @@ function readStringArray(value: unknown, field: string, profileName: string): st
 	return value as string[];
 }
 
-/** Legacy catalog key names, still accepted on read (canonical name wins).
- *  The write paths (/profile CRUD, /mcp enable|disable) delete the alias, so
- *  a file migrates to the canonical spelling the next time it is saved. */
-export const LEGACY_FIELD_ALIASES = { mcps: "mcp" } as const;
-
-/** Reads an array-of-strings field under its canonical name or a legacy
- *  alias. Both spellings are validated when present, so a value of the
- *  wrong type never passes silently through either key. */
-function readAliasedStringArray(
-	raw: Record<string, unknown>,
-	canonical: string,
-	legacy: string,
-	profileName: string,
-): string[] | undefined {
-	for (const key of [canonical, legacy]) {
-		if (raw[key] !== undefined) readStringArray(raw[key], key, profileName);
-	}
-	const source = raw[canonical] !== undefined ? canonical : legacy;
-	return readStringArray(raw[source], source, profileName);
-}
-
 function readOptionalString(value: unknown, field: string, profileName: string): string | undefined {
 	if (value === undefined) return undefined;
 	if (typeof value !== "string") {
@@ -115,9 +84,7 @@ function readOptionalString(value: unknown, field: string, profileName: string):
 }
 
 /** Parses one raw profile definition; exported for the write-side store
- *  (profile-catalog-store.ts) so anything written is loadable. Unknown
- *  fields are ignored by design — an `extensions` key left over from
- *  v0.1.0 is dropped silently, exactly like any other unknown key. */
+ *  (profile-catalog-store.ts) so anything written is loadable. */
 export function parseProfileDefinition(name: string, raw: unknown): ProfileDefinition {
 	if (!isRecord(raw)) {
 		throw new CatalogError(`profile "${name}" must be an object`);
@@ -127,61 +94,52 @@ export function parseProfileDefinition(name: string, raw: unknown): ProfileDefin
 	if (label !== undefined) definition.label = label;
 	const description = readOptionalString(raw.description, "description", name);
 	if (description !== undefined) definition.description = description;
-	for (const field of ["skills", "tools"] as const) {
+	for (const field of ["skills", "extensions", "mcps", "tools"] as const) {
 		const entries = readStringArray(raw[field], field, name);
 		if (entries !== undefined) definition[field] = entries;
 	}
-	const mcps = readAliasedStringArray(raw, "mcps", LEGACY_FIELD_ALIASES.mcps, name);
-	if (mcps !== undefined) definition.mcps = mcps;
-	if (raw.model !== undefined) {
-		if (!isRecord(raw.model) || typeof raw.model.provider !== "string" || typeof raw.model.id !== "string") {
-			throw new CatalogError(`profile "${name}": "model" must be an object with string "provider" and "id"`);
-		}
-		const thinkingLevel = readOptionalString(raw.model.thinkingLevel, "model.thinkingLevel", name);
-		definition.model = { provider: raw.model.provider, id: raw.model.id, ...(thinkingLevel ? { thinkingLevel } : {}) };
-	}
+	const defaultProvider = readOptionalString(raw.defaultProvider, "defaultProvider", name);
+	if (defaultProvider !== undefined) definition.defaultProvider = defaultProvider;
+	const defaultModel = readOptionalString(raw.defaultModel, "defaultModel", name);
+	if (defaultModel !== undefined) definition.defaultModel = defaultModel;
+	const defaultThinkingLevel = readOptionalString(raw.defaultThinkingLevel, "defaultThinkingLevel", name);
+	if (defaultThinkingLevel !== undefined) definition.defaultThinkingLevel = defaultThinkingLevel;
 	const instructions = readOptionalString(raw.instructions, "instructions", name);
 	if (instructions !== undefined) definition.instructions = instructions;
 	return definition;
 }
 
-/** Parses one catalog document. Missing files are handled by the caller;
- *  this function sees only parsed JSON. */
-export function parseCatalogDocument(value: unknown, filePath: string): Map<string, ProfileDefinition> {
-	if (!isRecord(value)) {
-		throw new CatalogError(`${filePath}: catalog must be an object`);
+/** Reads one catalog file; missing → empty map, malformed → CatalogError. */
+async function loadCatalogFile(catalogPath: string): Promise<Map<string, ProfileDefinition>> {
+	const result = await readJsonFile(catalogPath);
+	const profiles = new Map<string, ProfileDefinition>();
+	if (!result.ok) {
+		if (result.reason === "missing") return profiles;
+		throw new CatalogError(`invalid JSON in ${catalogPath}`);
 	}
-	const version = value.schemaVersion;
-	if (version !== PROFILE_SCHEMA_VERSION) {
+	const parsed = result.value;
+	if (!isRecord(parsed)) {
+		throw new CatalogError(`${catalogPath}: catalog must be an object`);
+	}
+	if (parsed.schemaVersion !== PROFILE_SCHEMA_VERSION) {
 		throw new CatalogError(
-			`${filePath}: unsupported schemaVersion ${JSON.stringify(version)} (expected ${PROFILE_SCHEMA_VERSION})`,
+			`${catalogPath}: unsupported schemaVersion ${JSON.stringify(parsed.schemaVersion)} (expected ${PROFILE_SCHEMA_VERSION})`,
 		);
 	}
-	if (!isRecord(value.profiles)) {
-		throw new CatalogError(`${filePath}: "profiles" must be an object mapping names to definitions`);
+	if (!isRecord(parsed.profiles)) {
+		throw new CatalogError(`${catalogPath}: "profiles" must be an object mapping names to definitions`);
 	}
-	const profiles = new Map<string, ProfileDefinition>();
-	for (const [name, raw] of Object.entries(value.profiles)) {
+	for (const [name, definition] of Object.entries(parsed.profiles)) {
 		if (name === DEFAULT_PROFILE_NAME) {
 			throw new CatalogError(
-				`${filePath}: "${DEFAULT_PROFILE_NAME}" is built in and must not be defined in the catalog`,
+				`${catalogPath}: "${DEFAULT_PROFILE_NAME}" is built in and must not be defined in the catalog`,
 			);
 		}
-		profiles.set(name, parseProfileDefinition(name, raw));
+		profiles.set(name, parseProfileDefinition(name, definition));
 	}
 	return profiles;
 }
 
-/** Reads one catalog file; missing → empty map, malformed → CatalogError. */
-async function loadCatalogFile(catalogPath: string): Promise<Map<string, ProfileDefinition>> {
-	const result = await readJsonFile(catalogPath);
-	if (!result.ok) {
-		if (result.reason === "missing") return new Map();
-		throw new CatalogError(`invalid JSON in ${catalogPath}`);
-	}
-	return parseCatalogDocument(result.value, catalogPath);
-}
-
 export class ProfileCatalog {
 	readonly #profiles: ReadonlyMap<string, CatalogEntry>;
 
@@ -191,19 +149,19 @@ export class ProfileCatalog {
 
 	/**
 	 * Reads the global catalog, plus the project catalog when `projectDir` is
-	 * given (trusted projects only — the caller gates on Pi's trust check).
+	 * given (trusted projects only — the caller gates on the trust check).
 	 * Missing files mean an empty catalog; malformed content throws
 	 * CatalogError. Project entries replace same-name global entries.
 	 */
 	static async load(agentDir: string, options?: { projectDir?: string }): Promise<ProfileCatalog> {
-		const global = await loadCatalogFile(path.join(agentDir, "profiles.json"));
+		const globalProfiles = await loadCatalogFile(resolveGlobalProfilesPath(agentDir));
 		const profiles = new Map<string, CatalogEntry>();
-		for (const [name, definition] of global) {
+		for (const [name, definition] of globalProfiles) {
 			profiles.set(name, { source: "global", definition });
 		}
 		if (options?.projectDir !== undefined) {
-			const project = await loadCatalogFile(path.join(options.projectDir, ".pi", "profiles.json"));
-			for (const [name, definition] of project) {
+			const projectProfiles = await loadCatalogFile(path.join(options.projectDir, ".pi", "profiles.json"));
+			for (const [name, definition] of projectProfiles) {
 				profiles.set(name, { source: "project", definition });
 			}
 		}
@@ -211,7 +169,7 @@ export class ProfileCatalog {
 	}
 
 	/** Resolves a profile by name. `default` always resolves to the built-in
-	 *  no-op profile; unknown names return undefined. */
+	 *  full-resource profile; unknown names return undefined. */
 	resolve(name: string): ResolvedProfile | undefined {
 		if (name === DEFAULT_PROFILE_NAME) {
 			return { name: DEFAULT_PROFILE_NAME, source: "builtin", definition: {} };
@@ -228,10 +186,4 @@ export class ProfileCatalog {
 			...[...this.#profiles.keys()].map((name) => this.resolve(name)!),
 		];
 	}
-
-	/** True when a global definition of the same name is shadowed by the
-	 *  project entry. */
-	shadowsGlobal(name: string): boolean {
-		return this.#profiles.get(name)?.source === "project";
-	}
 }