@bacnh85/pi-plan 0.1.6 → 0.1.7

package/index.ts

@@ -30,9 +30,9 @@ interface PlanState {
 }
 
 interface PlanPreferences {
-	version: 1;
-	planThinking: ThinkingLevel;
-	normalThinking: ThinkingLevel;
+	version: 2;
+	defaults: { planThinking: ThinkingLevel; normalThinking: ThinkingLevel };
+	perModel: Record<string, { planThinking: ThinkingLevel; normalThinking: ThinkingLevel }>;
 }
 
 interface WritePlanParams {
@@ -128,14 +128,35 @@ function hasOpenQuestionWarning(content: string): boolean {
 	return /(^|\n)#{1,6}\s+.*open questions?.*\n[\s\S]*\?/i.test(content);
 }
 
+function modelKey(model: { provider?: string; id?: string } | undefined): string | undefined {
+	if (!model?.provider || !model?.id) return undefined;
+	return `${model.provider}/${model.id}`;
+}
+
+function getEffectiveThinking(prefs: PlanPreferences, model: { provider?: string; id?: string } | undefined): { plan: ThinkingLevel; normal: ThinkingLevel } {
+	const key = modelKey(model);
+	const stored = key ? prefs.perModel[key] : undefined;
+	return {
+		plan: stored?.planThinking ?? prefs.defaults.planThinking,
+		normal: stored?.normalThinking ?? prefs.defaults.normalThinking,
+	};
+}
+
 async function loadPreferences(): Promise<PlanPreferences | undefined> {
 	try {
 		const raw = await readFile(PREFERENCES_FILE, "utf8");
-		const parsed = JSON.parse(raw) as Partial<PlanPreferences>;
-		const savedPlanThinking = parsed.planThinking;
-		const savedNormalThinking = parsed.normalThinking;
-		if (parsed.version !== 1 || !savedPlanThinking || !savedNormalThinking || !isThinkingLevel(savedPlanThinking) || !isThinkingLevel(savedNormalThinking)) return undefined;
-		return { version: 1, planThinking: savedPlanThinking, normalThinking: savedNormalThinking };
+		const parsed = JSON.parse(raw) as Record<string, any>;
+		if (parsed.version === 2 && isThinkingLevel(parsed.defaults?.planThinking) && isThinkingLevel(parsed.defaults?.normalThinking) && typeof parsed.perModel === "object" && parsed.perModel !== null) {
+			return { version: 2, defaults: parsed.defaults, perModel: parsed.perModel } as PlanPreferences;
+		}
+		if (parsed.version === 1 && isThinkingLevel(parsed.planThinking) && isThinkingLevel(parsed.normalThinking)) {
+			return {
+				version: 2,
+				defaults: { planThinking: parsed.planThinking as ThinkingLevel, normalThinking: parsed.normalThinking as ThinkingLevel },
+				perModel: {},
+			};
+		}
+		return undefined;
 	} catch {
 		return undefined;
 	}
@@ -248,8 +269,11 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		} satisfies PlanState);
 	}
 
+	let preferences: PlanPreferences | undefined;
+
 	function persistPreferences(): void {
-		void savePreferences({ version: 1, planThinking, normalThinking }).catch(() => undefined);
+		if (!preferences) return;
+		void savePreferences(preferences).catch(() => undefined);
 	}
 
 	function enablePlanTools(): void {
@@ -279,6 +303,10 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 			if (normalThinking === level) return;
 			normalThinking = level;
 		}
+		const key = modelKey(ctx.model);
+		if (key && preferences) {
+			preferences.perModel[key] = { planThinking, normalThinking };
+		}
 		setStatus(ctx);
 		persistState();
 		persistPreferences();
@@ -501,26 +529,29 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
-		const preferences = await loadPreferences();
+		preferences = await loadPreferences();
+		if (!preferences) {
+			preferences = { version: 2, defaults: { planThinking, normalThinking }, perModel: {} };
+		}
+		const effective = getEffectiveThinking(preferences, ctx.model);
+		planThinking = effective.plan;
+		normalThinking = effective.normal;
+
 		const entries = ctx.sessionManager.getEntries();
 		const saved = entries
 			.filter((entry: { type: string; customType?: string }) => entry.type === "custom" && entry.customType === "pi-plan")
 			.pop() as { data?: PlanState } | undefined;
-		if (preferences) {
-			planThinking = preferences.planThinking;
-			normalThinking = preferences.normalThinking;
-		}
 		if (saved?.data) {
 			planModeEnabled = saved.data.enabled ?? planModeEnabled;
 			executionMode = saved.data.executing ?? executionMode;
-			if (!preferences && isThinkingLevel(saved.data.planThinking)) planThinking = saved.data.planThinking;
-			if (!preferences && isThinkingLevel(saved.data.normalThinking)) normalThinking = saved.data.normalThinking;
+			if (isThinkingLevel(saved.data.planThinking)) planThinking = saved.data.planThinking;
+			if (isThinkingLevel(saved.data.normalThinking)) normalThinking = saved.data.normalThinking;
 			toolsBeforePlan = saved.data.toolsBeforePlan ?? toolsBeforePlan;
 			lastPlanPath = saved.data.lastPlanPath ?? lastPlanPath;
 			lastPlanTitle = saved.data.lastPlanTitle ?? lastPlanTitle;
 			lastPlanStatus = saved.data.lastPlanStatus ?? lastPlanStatus;
 		}
-		if (!preferences) persistPreferences();
+		persistPreferences();
 		if (pi.getFlag("plan") === true) planModeEnabled = true;
 		if (planModeEnabled) {
 			enablePlanTools();
@@ -532,6 +563,25 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		clearPlanWidget(ctx);
 	});
 
+	pi.on("model_select", async (event, ctx) => {
+		if (executionMode) return;
+		if (!preferences) return;
+		const effective = getEffectiveThinking(preferences, event.model);
+		if (planModeEnabled) {
+			if (planThinking !== effective.plan) {
+				planThinking = effective.plan;
+				applyThinking(planThinking);
+			}
+		} else {
+			if (normalThinking !== effective.normal) {
+				normalThinking = effective.normal;
+				applyThinking(normalThinking);
+			}
+		}
+		setStatus(ctx);
+		persistState();
+	});
+
 	pi.on("thinking_level_select", async (event, ctx) => {
 		if (applyingStoredThinking) return;
 		if (!isThinkingLevel(event.level)) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-plan",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Pi extension that adds a plan mode with workspace markdown plans and thinking-level presets.",
   "license": "MIT",
   "publishConfig": {