pi-model-profiles 0.2.0

package/src/frontmatter-parser.ts

@@ -0,0 +1,249 @@
+import { PROFILE_FIELD_KEYS, type ProfileFieldKey, type ProfileFields } from "./types.js";
+import { ModelProfilesError } from "./errors.js";
+
+interface FrontmatterDocument {
+	frontmatter: string;
+	body: string;
+}
+
+interface FrontmatterBlock {
+	key: string | null;
+	lines: string[];
+}
+
+const ANCHOR_KEYS = new Set(["name", "mode", "color", "description"]);
+const SAFE_UNQUOTED_SCALAR = /^[A-Za-z0-9._/@:-]+$/;
+const PROFILE_KEY_SET = new Set<string>(PROFILE_FIELD_KEYS);
+
+function normalizeNewlines(value: string): string {
+	return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+function extractTopLevelKey(line: string): string | null {
+	if (!line || line.startsWith(" ") || line.startsWith("\t")) {
+		return null;
+	}
+
+	const match = /^([A-Za-z0-9_-]+):(?:\s*(.*))?$/.exec(line);
+	if (!match) {
+		return null;
+	}
+
+	return match[1] ?? null;
+}
+
+function parseScalarText(value: string): string {
+	const trimmed = value.trim();
+	if (!trimmed) {
+		return "";
+	}
+	if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+		try {
+			return JSON.parse(trimmed) as string;
+		} catch {
+			return trimmed.slice(1, -1);
+		}
+	}
+	if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+		return trimmed.slice(1, -1).replace(/''/g, "'");
+	}
+	return trimmed;
+}
+
+function splitFrontmatterBlocks(frontmatter: string): FrontmatterBlock[] {
+	const lines = frontmatter.split("\n");
+	const starts: Array<{ index: number; key: string }> = [];
+
+	for (let index = 0; index < lines.length; index += 1) {
+		const key = extractTopLevelKey(lines[index] ?? "");
+		if (key) {
+			starts.push({ index, key });
+		}
+	}
+
+	if (starts.length === 0) {
+		return [{ key: null, lines }];
+	}
+
+	const blocks: FrontmatterBlock[] = [];
+	if ((starts[0]?.index ?? 0) > 0) {
+		blocks.push({ key: null, lines: lines.slice(0, starts[0]?.index) });
+	}
+
+	for (let index = 0; index < starts.length; index += 1) {
+		const current = starts[index];
+		const next = starts[index + 1];
+		blocks.push({
+			key: current?.key ?? null,
+			lines: lines.slice(current?.index ?? 0, next ? next.index : lines.length),
+		});
+	}
+
+	return blocks.filter((block) => block.lines.length > 0);
+}
+
+function trimBlankEdges(lines: string[]): string[] {
+	let start = 0;
+	let end = lines.length;
+	while (start < end && !(lines[start] ?? "").trim()) {
+		start += 1;
+	}
+	while (end > start && !(lines[end - 1] ?? "").trim()) {
+		end -= 1;
+	}
+	return lines.slice(start, end);
+}
+
+function joinBlocks(blocks: FrontmatterBlock[]): string {
+	const lines = blocks.flatMap((block) => block.lines);
+	return trimBlankEdges(lines).join("\n");
+}
+
+function serializeScalar(value: string): string {
+	return SAFE_UNQUOTED_SCALAR.test(value) ? value : JSON.stringify(value);
+}
+
+function serializeProfileLines(fields: ProfileFields): string[] {
+	const lines: string[] = [];
+	if (fields.model !== undefined) {
+		lines.push(`model: ${serializeScalar(fields.model)}`);
+	}
+	if (fields.temperature !== undefined) {
+		lines.push(`temperature: ${String(fields.temperature)}`);
+	}
+	if (fields.reasoningEffort !== undefined) {
+		lines.push(`reasoningEffort: ${serializeScalar(fields.reasoningEffort)}`);
+	}
+	return lines;
+}
+
+function findInsertIndex(blocks: FrontmatterBlock[]): number {
+	const firstProfileIndex = blocks.findIndex((block) => block.key !== null && PROFILE_KEY_SET.has(block.key));
+	if (firstProfileIndex !== -1) {
+		let keptBefore = 0;
+		for (let index = 0; index < firstProfileIndex; index += 1) {
+			if (!PROFILE_KEY_SET.has(blocks[index]?.key ?? "")) {
+				keptBefore += 1;
+			}
+		}
+		return keptBefore;
+	}
+
+	let lastAnchorIndex = -1;
+	for (let index = 0; index < blocks.length; index += 1) {
+		const key = blocks[index]?.key;
+		if (key && ANCHOR_KEYS.has(key)) {
+			lastAnchorIndex = index;
+		}
+	}
+
+	if (lastAnchorIndex !== -1) {
+		return lastAnchorIndex + 1;
+	}
+
+	return blocks[0]?.key === null ? 1 : 0;
+}
+
+export function extractFrontmatterDocument(markdown: string): FrontmatterDocument {
+	const normalized = normalizeNewlines(markdown);
+	const lines = normalized.split("\n");
+	if ((lines[0] ?? "") !== "---") {
+		throw new ModelProfilesError("Agent markdown is missing opening frontmatter delimiter.", "INVALID_FRONTMATTER");
+	}
+
+	let endIndex = -1;
+	for (let index = 1; index < lines.length; index += 1) {
+		if ((lines[index] ?? "") === "---") {
+			endIndex = index;
+			break;
+		}
+	}
+
+	if (endIndex === -1) {
+		throw new ModelProfilesError("Agent markdown is missing closing frontmatter delimiter.", "INVALID_FRONTMATTER");
+	}
+
+	return {
+		frontmatter: lines.slice(1, endIndex).join("\n"),
+		body: lines.slice(endIndex + 1).join("\n"),
+	};
+}
+
+export function readTopLevelScalarMap(frontmatter: string): Record<string, string> {
+	const values: Record<string, string> = {};
+	for (const line of frontmatter.split("\n")) {
+		const key = extractTopLevelKey(line);
+		if (!key) {
+			continue;
+		}
+		const separatorIndex = line.indexOf(":");
+		const rawValue = line.slice(separatorIndex + 1).trim();
+		if (!rawValue) {
+			continue;
+		}
+		values[key] = parseScalarText(rawValue);
+	}
+	return values;
+}
+
+export function readAgentNameFromMarkdown(markdown: string): string {
+	const { frontmatter } = extractFrontmatterDocument(markdown);
+	const name = readTopLevelScalarMap(frontmatter).name?.trim();
+	if (!name) {
+		throw new ModelProfilesError("Agent markdown frontmatter is missing a non-empty 'name' field.", "INVALID_AGENT_NAME");
+	}
+	return name;
+}
+
+export function readProfileFieldsFromMarkdown(markdown: string): ProfileFields {
+	const { frontmatter } = extractFrontmatterDocument(markdown);
+	const values = readTopLevelScalarMap(frontmatter);
+	const fields: ProfileFields = {};
+
+	const model = values.model?.trim();
+	if (model) {
+		fields.model = model;
+	}
+
+	if (values.temperature !== undefined) {
+		const parsedTemperature = Number.parseFloat(values.temperature);
+		if (!Number.isFinite(parsedTemperature)) {
+			throw new ModelProfilesError(
+				`Frontmatter field 'temperature' must be numeric, received '${values.temperature}'.`,
+				"INVALID_TEMPERATURE",
+			);
+		}
+		fields.temperature = parsedTemperature;
+	}
+
+	const reasoningEffort = values.reasoningEffort?.trim();
+	if (reasoningEffort) {
+		fields.reasoningEffort = reasoningEffort;
+	}
+
+	return fields;
+}
+
+export function updateMarkdownProfileFields(markdown: string, fields: ProfileFields): string {
+	const document = extractFrontmatterDocument(markdown);
+	const originalBlocks = splitFrontmatterBlocks(document.frontmatter);
+	const keptBlocks = originalBlocks.filter((block) => !PROFILE_KEY_SET.has(block.key ?? ""));
+	const insertIndex = findInsertIndex(originalBlocks);
+	const profileLines = serializeProfileLines(fields);
+	const nextBlocks = [...keptBlocks];
+
+	if (profileLines.length > 0) {
+		nextBlocks.splice(insertIndex, 0, { key: null, lines: profileLines });
+	}
+
+	const nextFrontmatter = joinBlocks(nextBlocks);
+	return `---\n${nextFrontmatter}\n---\n${document.body}`;
+}
+
+export function listAppliedKeys(fields: ProfileFields): ProfileFieldKey[] {
+	return PROFILE_FIELD_KEYS.filter((key) => fields[key] !== undefined);
+}
+
+export function listRemovedKeys(fields: ProfileFields): ProfileFieldKey[] {
+	return PROFILE_FIELD_KEYS.filter((key) => fields[key] === undefined);
+}

package/src/import-service.ts

@@ -0,0 +1,60 @@
+import { AGENTS_DIR, INITIAL_PROFILE_NAME, PROFILE_STORE_PATH } from "./constants.js";
+import { captureAgentSnapshots, type AgentSelectionOptions } from "./agent-writer.js";
+import { appendProfile, createProfile, loadProfilesFile, resolveUniqueProfileName, saveProfilesFile } from "./profile-store.js";
+import { loadMultiProfilesConfig } from "./config.js";
+import { multiProfilesDebugLogger } from "./debug-logger.js";
+import type { ImportProfilesResult, ProfilesFile } from "./types.js";
+
+export function ensureProfilesImported(
+	data: ProfilesFile,
+	agentOptions: string | AgentSelectionOptions = AGENTS_DIR,
+): ImportProfilesResult {
+	if (data.importedAt) {
+		return {
+			data,
+			imported: false,
+			importedCount: 0,
+			warnings: [],
+		};
+	}
+
+	const snapshot = captureAgentSnapshots(agentOptions);
+	const timestamp = new Date().toISOString();
+	const profile = createProfile(resolveUniqueProfileName(INITIAL_PROFILE_NAME, data.profiles), snapshot.agents, { timestamp });
+
+	return {
+		data: {
+			...appendProfile(data, profile),
+			importedAt: timestamp,
+		},
+		imported: true,
+		importedCount: 1,
+		warnings: snapshot.warnings,
+	};
+}
+
+export function loadAndPrepareProfiles(
+	storePath = PROFILE_STORE_PATH,
+	agentOptions: string | AgentSelectionOptions = AGENTS_DIR,
+): ImportProfilesResult {
+	const configLoad = loadMultiProfilesConfig();
+
+	multiProfilesDebugLogger.log("extension.initialized", {
+		configCreated: configLoad.created,
+		timestamp: new Date().toISOString(),
+		profilesVersion: 2,
+	});
+
+	const loaded = loadProfilesFile(storePath, agentOptions);
+	const prepared = ensureProfilesImported(loaded.data, agentOptions);
+
+	if (loaded.needsSave || prepared.imported) {
+		saveProfilesFile(prepared.data, storePath);
+	}
+
+	const warnings = [configLoad.warning, loaded.warning, ...prepared.warnings].filter((message): message is string => Boolean(message));
+	return {
+		...prepared,
+		warnings,
+	};
+}

package/src/index.ts

@@ -0,0 +1,158 @@
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+import { COMMAND_NAME, INITIAL_PROFILE_NAME, PROFILE_NAME_SUFFIX, PROFILE_STORE_PATH } from "./constants.js";
+import { applySavedProfile, captureAgentSnapshots, detectActiveAgentName } from "./agent-writer.js";
+import { toErrorMessage } from "./errors.js";
+import { loadAndPrepareProfiles } from "./import-service.js";
+import { updateProfileAndReturn } from "./profile-update-service.js";
+import { appendProfile, createProfile, findProfileById, renameStoredProfile, resolveUniqueProfileName, saveProfilesFile } from "./profile-store.js";
+import { removeProfileAndUpdate } from "./profile-removal-service.js";
+import { openProfilesModal, type ProfileModalResult } from "./profile-modal.js";
+import { onResourcesDiscover, refreshModelRegistry } from "./pi-api-utils.js";
+import type { AppliedProfileOutcome, ProfilesFile } from "./types.js";
+
+function buildCurrentProfileName(activeAgentName: string | null, data: ProfilesFile): string {
+	const baseName = activeAgentName ? `${activeAgentName} ${PROFILE_NAME_SUFFIX}` : INITIAL_PROFILE_NAME;
+	return resolveUniqueProfileName(baseName, data.profiles);
+}
+
+function notifyWarnings(ctx: ExtensionCommandContext, warnings: readonly string[]): void {
+	if (warnings.length === 0) {
+		return;
+	}
+	ctx.ui.notify(warnings.join(" "), "warning");
+}
+
+function summarizeApplyOutcome(outcome: AppliedProfileOutcome): string {
+	const appliedCount = outcome.appliedAgents.length;
+	const missingCount = outcome.missingAgents.length;
+	const appliedLabel = `${appliedCount} agent file${appliedCount === 1 ? "" : "s"}`;
+	if (missingCount === 0) {
+		return appliedLabel;
+	}
+	return `${appliedLabel}; ${missingCount} missing`;
+}
+
+async function reloadAfterApply(ctx: ExtensionCommandContext, outcome: AppliedProfileOutcome): Promise<void> {
+	const summary = summarizeApplyOutcome(outcome);
+	ctx.ui.notify(`Profile '${outcome.profileName}' applied across ${summary}. Reloading…`, "info");
+
+	try {
+		await ctx.reload();
+	} catch (error) {
+		ctx.ui.notify(
+			`Profile '${outcome.profileName}' applied across ${summary}, but automatic reload failed: ${toErrorMessage(error)}. Run /reload.`,
+			"error",
+		);
+	}
+}
+
+async function handleModelProfilesCommand(ctx: ExtensionCommandContext): Promise<void> {
+	const agentOptions = { cwd: ctx.cwd, scope: "both" as const };
+	const prepared = loadAndPrepareProfiles(PROFILE_STORE_PATH, agentOptions);
+	notifyWarnings(ctx, prepared.warnings);
+
+	let data = prepared.data;
+	const activeAgentName = detectActiveAgentName(ctx.sessionManager, ctx.getSystemPrompt());
+
+	const result: ProfileModalResult = await openProfilesModal(ctx, data, activeAgentName, {
+		renameProfile: async (profileId, nextName) => {
+			data = renameStoredProfile(data, profileId, nextName);
+			saveProfilesFile(data, PROFILE_STORE_PATH);
+			return {
+				data,
+				message: `Renamed saved snapshot to '${nextName.trim()}'.`,
+				selectedProfileId: profileId,
+			};
+		},
+		addCurrentProfile: async () => {
+			const snapshot = captureAgentSnapshots(agentOptions);
+			notifyWarnings(ctx, snapshot.warnings);
+			const profile = createProfile(buildCurrentProfileName(activeAgentName, data), snapshot.agents);
+			data = appendProfile(data, profile);
+			saveProfilesFile(data, PROFILE_STORE_PATH);
+			return {
+				data,
+				message: `Saved current agents snapshot (${snapshot.agents.length} agents).`,
+				selectedProfileId: profile.id,
+			};
+		},
+		applyProfile: async (profileId) => {
+			const profile = findProfileById(data, profileId);
+			if (!profile) {
+				throw new Error(`Saved profile '${profileId}' was not found.`);
+			}
+			const applied = applySavedProfile(profile, agentOptions);
+			notifyWarnings(ctx, applied.warnings);
+			return {
+				...applied,
+				profileName: profile.name,
+			};
+		},
+		removeProfile: async (profileId) => {
+			const profile = findProfileById(data, profileId);
+			if (!profile) {
+				throw new Error(`Saved profile '${profileId}' was not found.`);
+			}
+			const removal = removeProfileAndUpdate(data, profileId);
+			data = removal.data;
+			saveProfilesFile(data, PROFILE_STORE_PATH);
+			return {
+				data,
+				message: `Removed saved snapshot '${removal.result.removedProfileName}' (${removal.result.remainingCount} snapshots remaining).`,
+				selectedProfileId: data.profiles[0]?.id,
+			};
+		},
+		updateProfile: async (profileId) => {
+			const profile = findProfileById(data, profileId);
+			if (!profile) {
+				throw new Error(`Saved profile '${profileId}' was not found.`);
+			}
+			const update = updateProfileAndReturn(data, profileId, agentOptions);
+			notifyWarnings(ctx, update.result.warnings);
+			data = update.data;
+			saveProfilesFile(data, PROFILE_STORE_PATH);
+			return {
+				data,
+				message: `Updated '${profile.name}' with current agent state (${update.result.updatedAgents} agents).`,
+				selectedProfileId: profileId,
+			};
+		},
+	});
+
+	if (result.type === "applied") {
+		await reloadAfterApply(ctx, result.outcome);
+		return;
+	}
+}
+
+export default function modelProfilesExtension(pi: ExtensionAPI): void {
+	// Register handler to refresh model registry on /reload
+	// This works around the issue where AgentSession.reload() doesn't call ModelRegistry.refresh()
+	onResourcesDiscover(pi, (event, ctx): void => {
+		if (event.reason === "reload") {
+			refreshModelRegistry(ctx);
+		}
+	});
+
+	pi.registerCommand(COMMAND_NAME, {
+		description: "Open saved whole-agent model profile snapshots",
+		handler: async (args: string, ctx: ExtensionCommandContext): Promise<void> => {
+			if (args.trim()) {
+				ctx.ui.notify(`Usage: /${COMMAND_NAME}`, "warning");
+				return;
+			}
+
+			if (!ctx.hasUI) {
+				ctx.ui.notify(`/${COMMAND_NAME} requires interactive TUI mode.`, "warning");
+				return;
+			}
+
+			try {
+				await handleModelProfilesCommand(ctx);
+			} catch (error) {
+				ctx.ui.notify(`/${COMMAND_NAME} failed: ${toErrorMessage(error)}`, "error");
+			}
+		},
+	});
+}