@plannotator/pi-extension 0.16.2 → 0.16.3

package/index.ts

@@ -21,7 +21,7 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { AgentMessage, ThinkingLevel } from "@mariozechner/pi-agent-core";
 import type { AssistantMessage, TextContent } from "@mariozechner/pi-ai";
 import { Type } from "@mariozechner/pi-ai";
 import type {
@@ -29,6 +29,7 @@ import type {
 	ExtensionContext,
 } from "@mariozechner/pi-coding-agent";
 import { Key } from "@mariozechner/pi-tui";
+import { buildPromptVariables, formatTodoList, loadPlannotatorConfig, renderTemplate, resolvePhaseProfile } from "./config.js";
 import {
 	type ChecklistItem,
 	markCompletedSteps,
@@ -85,6 +86,20 @@ try {
 	// HTML not built yet — review feature will be unavailable
 }
 
+
+
+type SavedPhaseState = {
+	activeTools: string[];
+	model?: { provider: string; id: string };
+	thinkingLevel: ThinkingLevel;
+};
+
+type PersistedPlannotatorState = {
+	phase: Phase;
+	planFilePath?: string;
+	savedState?: SavedPhaseState;
+};
+
 function isAssistantMessage(m: AgentMessage): m is AssistantMessage {
 	return m.role === "assistant" && Array.isArray(m.content);
 }
@@ -122,11 +137,24 @@ function getStartupErrorMessage(err: unknown): string {
 	return err instanceof Error ? err.message : "Unknown error";
 }
 
+function getPlanReviewAvailabilityWarning(options: { hasUI: boolean; hasPlanHtml: boolean }): string | null {
+	const { hasUI, hasPlanHtml } = options;
+	if (hasUI && hasPlanHtml) return null;
+	if (!hasUI && !hasPlanHtml) {
+		return "Plannotator: interactive plan review is unavailable in this session (no UI support and missing built assets). Plans will auto-approve on exit_plan_mode.";
+	}
+	if (!hasUI) {
+		return "Plannotator: interactive plan review is unavailable in this session (no UI support). Plans will auto-approve on exit_plan_mode.";
+	}
+	return "Plannotator: interactive plan review assets are missing. Rebuild the extension to restore the browser UI. Plans will auto-approve on exit_plan_mode.";
+}
+
 export default function plannotator(pi: ExtensionAPI): void {
 	let phase: Phase = "idle";
 	let planFilePath = "PLAN.md";
 	let checklistItems: ChecklistItem[] = [];
-	let preplanTools: string[] | null = null;
+	let savedState: SavedPhaseState | null = null;
+	let plannotatorConfig = {};
 
 	// ── Flags ────────────────────────────────────────────────────────────
 
@@ -148,15 +176,25 @@ export default function plannotator(pi: ExtensionAPI): void {
 		return resolve(cwd, planFilePath);
 	}
 
+	function getPhaseProfile(): ReturnType<typeof resolvePhaseProfile> | undefined {
+		if (phase === "planning" || phase === "executing") {
+			return resolvePhaseProfile(plannotatorConfig, phase);
+		}
+		return undefined;
+	}
+
 	function updateStatus(ctx: ExtensionContext): void {
+		const profile = getPhaseProfile();
 		if (phase === "executing" && checklistItems.length > 0) {
 			const completed = checklistItems.filter((t) => t.completed).length;
 			ctx.ui.setStatus(
 				"plannotator",
 				ctx.ui.theme.fg("accent", `📋 ${completed}/${checklistItems.length}`),
 			);
-		} else if (phase === "planning") {
-			ctx.ui.setStatus("plannotator", ctx.ui.theme.fg("warning", "⏸ plan"));
+		} else if (phase === "planning" && profile?.statusLabel) {
+			ctx.ui.setStatus("plannotator", ctx.ui.theme.fg("warning", profile.statusLabel));
+		} else if (phase === "executing" && profile?.statusLabel) {
+			ctx.ui.setStatus("plannotator", ctx.ui.theme.fg("accent", profile.statusLabel));
 		} else {
 			ctx.ui.setStatus("plannotator", undefined);
 		}
@@ -179,45 +217,109 @@ export default function plannotator(pi: ExtensionAPI): void {
 		}
 	}
 
+	function captureSavedState(ctx: ExtensionContext): void {
+		savedState = {
+			activeTools: pi.getActiveTools(),
+			model: ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined,
+			thinkingLevel: pi.getThinkingLevel(),
+		};
+	}
+
 	function persistState(): void {
-		pi.appendEntry("plannotator", { phase, planFilePath, preplanTools });
+
+
+		pi.appendEntry("plannotator", { phase, planFilePath, savedState });
 	}
 
-	/** Apply tool visibility for the current phase, preserving tools from other extensions. */
-	function applyToolsForPhase(): void {
-		const baseTools = stripPlanningOnlyTools(preplanTools ?? pi.getActiveTools());
-		pi.setActiveTools(getToolsForPhase(baseTools, phase));
+	async function applyModelRef(
+		ref: { provider: string; id: string },
+		ctx: ExtensionContext,
+		reason: string,
+	): Promise<void> {
+		const model = ctx.modelRegistry.find(ref.provider, ref.id);
+		if (!model) {
+			ctx.ui.notify(`Plannotator: ${reason} model ${ref.provider}/${ref.id} not found.`, "warning");
+			return;
+		}
+
+		const success = await pi.setModel(model);
+		if (!success) {
+			ctx.ui.notify(`Plannotator: no API key for ${ref.provider}/${ref.id}.`, "warning");
+		}
 	}
 
-	function enterPlanning(ctx: ExtensionContext): void {
-		phase = "planning";
-		checklistItems = [];
-		preplanTools = stripPlanningOnlyTools(pi.getActiveTools());
-		applyToolsForPhase();
+	async function restoreSavedState(ctx: ExtensionContext): Promise<void> {
+		if (!savedState) return;
+
+		pi.setActiveTools(savedState.activeTools);
+		if (savedState.model) {
+			await applyModelRef(savedState.model, ctx, "restore");
+		}
+		pi.setThinkingLevel(savedState.thinkingLevel);
+	}
+
+	async function applyPhaseConfig(ctx: ExtensionContext, opts: { restoreSavedState?: boolean } = {}): Promise<void> {
+		const profile = getPhaseProfile();
+		if (opts.restoreSavedState !== false && savedState) {
+			await restoreSavedState(ctx);
+		}
+
+		if (phase === "planning" || phase === "executing") {
+			const baseTools = stripPlanningOnlyTools(savedState?.activeTools ?? pi.getActiveTools());
+			const toolSet = new Set(baseTools);
+			for (const tool of profile?.activeTools ?? []) toolSet.add(tool);
+			if (phase === "planning") {
+				pi.setActiveTools(getToolsForPhase([...toolSet], phase));
+			} else {
+				pi.setActiveTools([...toolSet]);
+			}
+		}
+
+		if (profile?.model) {
+			await applyModelRef(profile.model, ctx, phase);
+		}
+
+		if (profile?.thinking) {
+			pi.setThinkingLevel(profile.thinking);
+		}
+
 		updateStatus(ctx);
 		updateWidget(ctx);
+	}
+
+	async function enterPlanning(ctx: ExtensionContext): Promise<void> {
+		phase = "planning";
+		checklistItems = [];
+		captureSavedState(ctx);
+		await applyPhaseConfig(ctx, { restoreSavedState: false });
 		persistState();
 		ctx.ui.notify(
 			`Plannotator: planning mode enabled. Write your plan to ${planFilePath}.`,
 		);
+		const warning = getPlanReviewAvailabilityWarning({ hasUI: ctx.hasUI, hasPlanHtml: Boolean(planHtmlContent) });
+		if (warning) {
+			ctx.ui.notify(warning, "warning");
+		}
 	}
 
-	function exitToIdle(ctx: ExtensionContext): void {
+	async function exitToIdle(ctx: ExtensionContext): Promise<void> {
 		phase = "idle";
 		checklistItems = [];
-		applyToolsForPhase();
-		preplanTools = null;
+
+
+		await restoreSavedState(ctx);
+		savedState = null;
 		updateStatus(ctx);
 		updateWidget(ctx);
 		persistState();
 		ctx.ui.notify("Plannotator: disabled. Full access restored.");
 	}
 
-	function togglePlanMode(ctx: ExtensionContext): void {
+	async function togglePlanMode(ctx: ExtensionContext): Promise<void> {
 		if (phase === "idle") {
-			enterPlanning(ctx);
+			await enterPlanning(ctx);
 		} else {
-			exitToIdle(ctx);
+			await exitToIdle(ctx);
 		}
 	}
 
@@ -227,7 +329,7 @@ export default function plannotator(pi: ExtensionAPI): void {
 		description: "Toggle plannotator (file-based plan mode)",
 		handler: async (args, ctx) => {
 			if (phase !== "idle") {
-				exitToIdle(ctx);
+				await exitToIdle(ctx);
 				return;
 			}
 
@@ -241,7 +343,7 @@ export default function plannotator(pi: ExtensionAPI): void {
 			}
 
 			if (targetPath) planFilePath = targetPath;
-			enterPlanning(ctx);
+			await enterPlanning(ctx);
 		},
 	});
 
@@ -540,7 +642,9 @@ export default function plannotator(pi: ExtensionAPI): void {
 
 	pi.registerShortcut(Key.ctrlAlt("p"), {
 		description: "Toggle plannotator",
-		handler: async (ctx) => togglePlanMode(ctx),
+		handler: async (ctx) => {
+			await togglePlanMode(ctx);
+		},
 	});
 
 	// ── plannotator_submit_plan Tool ────────────────────────────────────
@@ -610,8 +714,10 @@ export default function plannotator(pi: ExtensionAPI): void {
 			// Non-interactive or no HTML: auto-approve
 			if (!ctx.hasUI || !planHtmlContent) {
 				phase = "executing";
-				applyToolsForPhase();
-				preplanTools = null;
+
+
+				await applyPhaseConfig(ctx, { restoreSavedState: true });
+				pi.appendEntry("plannotator-execute", { planFilePath });
 				persistState();
 				return {
 					content: [
@@ -648,13 +754,11 @@ export default function plannotator(pi: ExtensionAPI): void {
 
 			if (result.approved) {
 				phase = "executing";
-				applyToolsForPhase();
-				preplanTools = null;
-				updateStatus(ctx);
-				updateWidget(ctx);
-				persistState();
 
+
+				await applyPhaseConfig(ctx, { restoreSavedState: true });
 				pi.appendEntry("plannotator-execute", { planFilePath });
+				persistState();
 
 				const doneMsg =
 					checklistItems.length > 0
@@ -731,6 +835,41 @@ export default function plannotator(pi: ExtensionAPI): void {
 
 	// Inject phase-specific context
 	pi.on("before_agent_start", async (_event, ctx) => {
+		const profile = getPhaseProfile();
+		if (phase === "executing") {
+			// Re-read from disk each turn to stay current
+			const fullPath = resolvePlanPath(ctx.cwd);
+			try {
+				const planContent = readFileSync(fullPath, "utf-8");
+				checklistItems = parseChecklist(planContent);
+			} catch {
+				// File deleted during execution — degrade gracefully
+			}
+		}
+
+		const todoStats = phase === "executing" ? formatTodoList(checklistItems) : formatTodoList([]);
+		if (profile?.systemPrompt) {
+			const rendered = renderTemplate(
+				profile.systemPrompt,
+				buildPromptVariables({
+					planFilePath,
+					phase,
+					todoList: todoStats.todoList,
+					completedCount: todoStats.completedCount,
+					totalCount: todoStats.totalCount,
+					remainingCount: todoStats.remainingCount,
+				}),
+			);
+			if (rendered.unknownVariables.length > 0) {
+				ctx.ui.notify(
+					"Plannotator: unknown template variables in " + phase + " prompt: " + rendered.unknownVariables.join(", "),
+					"warning",
+				);
+			}
+
+			return { systemPrompt: rendered.text };
+		}
+
 		if (phase === "planning") {
 			return {
 				message: {
@@ -892,8 +1031,10 @@ Execute each step in order. After completing a step, include [DONE:n] in your re
 			);
 			phase = "idle";
 			checklistItems = [];
-			applyToolsForPhase();
-			preplanTools = null;
+
+
+			await restoreSavedState(ctx);
+			savedState = null;
 			updateStatus(ctx);
 			updateWidget(ctx);
 			persistState();
@@ -908,6 +1049,12 @@ Execute each step in order. After completing a step, include [DONE:n] in your re
 			planFilePath = flagPlanFile;
 		}
 
+		const loadedConfig = loadPlannotatorConfig(ctx.cwd);
+		plannotatorConfig = loadedConfig.config;
+		for (const warning of loadedConfig.warnings) {
+			ctx.ui.notify(`Plannotator config: ${warning}`, "warning");
+		}
+
 		// Check --plan flag
 		if (pi.getFlag("plan") === true) {
 			phase = "planning";
@@ -920,14 +1067,16 @@ Execute each step in order. After completing a step, include [DONE:n] in your re
 				(e: { type: string; customType?: string }) =>
 					e.type === "custom" && e.customType === "plannotator",
 			)
-			.pop() as {
-				data?: { phase: Phase; planFilePath?: string; preplanTools?: string[] | null };
-			} | undefined;
+
+
+			.pop() as { data?: PersistedPlannotatorState } | undefined;
 
 		if (stateEntry?.data) {
 			phase = stateEntry.data.phase ?? phase;
 			planFilePath = stateEntry.data.planFilePath ?? planFilePath;
-			preplanTools = stateEntry.data.preplanTools ?? preplanTools;
+
+
+			savedState = stateEntry.data.savedState ?? savedState;
 		}
 
 		// Rebuild execution state from disk + session messages
@@ -964,11 +1113,25 @@ Execute each step in order. After completing a step, include [DONE:n] in your re
 			}
 		}
 
-		// Re-apply tool visibility on startup/resume so planning-only tools stay hidden
-		// outside planning and pre-plan tool state is restored after approvals.
-		applyToolsForPhase();
+
+
+		if (phase === "planning") {
+			checklistItems = [];
+			const warning = getPlanReviewAvailabilityWarning({ hasUI: ctx.hasUI, hasPlanHtml: Boolean(planHtmlContent) });
+			if (warning) {
+				ctx.ui.notify(warning, "warning");
+			}
+		}
+
+		if (phase === "idle") {
+			await restoreSavedState(ctx);
+			savedState = null;
+		} else if (phase === "planning" || phase === "executing") {
+			await applyPhaseConfig(ctx, { restoreSavedState: true });
+		}
 
 		updateStatus(ctx);
 		updateWidget(ctx);
+		persistState();
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plannotator/pi-extension",
-  "version": "0.16.2",
+  "version": "0.16.3",
   "type": "module",
   "description": "Plannotator extension for Pi coding agent - interactive plan review with visual annotation",
   "author": "backnotprop",
@@ -23,6 +23,8 @@
     "index.ts",
     "server.ts",
     "tool-scope.ts",
+    "config.ts",
+    "plannotator.json",
     "server/",
     "generated/",
     "README.md",