@milanglacier/pi-plan-mode 0.5.1

package/state.ts

@@ -0,0 +1,164 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { requirePiTuiModule } from "./qna";
+
+import type { PlanModeState } from "./types";
+
+import { resolveActivePlanFilePath } from "./plan-files";
+import { createInactivePlanModeState, isPlanModeState } from "./utils";
+
+function getPiTui() {
+	return requirePiTuiModule() as {
+		truncateToWidth: (text: string, width: number) => string;
+		wrapTextWithAnsi: (text: string, width: number) => string[];
+	};
+}
+
+export const STATE_ENTRY_TYPE = "pi-plan:state";
+export const CONTEXT_ENTRY_TYPE = "pi-plan:context";
+const BANNER_WIDGET_KEY = "pi-plan-banner";
+const PLAN_MODE_TOOL_NAMES = ["request_user_input", "set_plan"] as const;
+const PLAN_MODE_TOOL_NAME_SET = new Set<string>(PLAN_MODE_TOOL_NAMES);
+
+export function getLatestState(ctx: ExtensionContext): PlanModeState {
+	const entries = ctx.sessionManager.getEntries();
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const entry = entries[i];
+		if (entry.type !== "custom" || entry.customType !== STATE_ENTRY_TYPE) {
+			continue;
+		}
+		if (isPlanModeState(entry.data)) {
+			return entry.data;
+		}
+	}
+	return createInactivePlanModeState();
+}
+
+export function hasEntryInSession(ctx: ExtensionContext, entryId: string | undefined): boolean {
+	if (!entryId) {
+		return false;
+	}
+	for (const entry of ctx.sessionManager.getEntries()) {
+		if (entry.id === entryId) {
+			return true;
+		}
+	}
+	return false;
+}
+
+export function getFirstUserMessageId(ctx: ExtensionContext): string | undefined {
+	for (const entry of ctx.sessionManager.getEntries()) {
+		if (entry.type === "message" && entry.message.role === "user") {
+			return entry.id;
+		}
+	}
+	return undefined;
+}
+
+export function createPlanModeStateManager(pi: ExtensionAPI) {
+	let state: PlanModeState = createInactivePlanModeState();
+
+	const persistState = () => {
+		pi.appendEntry(STATE_ENTRY_TYPE, state);
+	};
+
+	const areSameToolLists = (left: string[], right: string[]) => {
+		if (left.length !== right.length) {
+			return false;
+		}
+		for (let i = 0; i < left.length; i++) {
+			if (left[i] !== right[i]) {
+				return false;
+			}
+		}
+		return true;
+	};
+
+	const syncPlanModeTools = () => {
+		const activeTools = pi.getActiveTools();
+		const nextTools = state.active
+			? [...activeTools, ...PLAN_MODE_TOOL_NAMES.filter((toolName) => !activeTools.includes(toolName))]
+			: activeTools.filter((toolName) => !PLAN_MODE_TOOL_NAME_SET.has(toolName));
+
+		if (areSameToolLists(activeTools, nextTools)) {
+			return;
+		}
+
+		pi.setActiveTools(nextTools);
+	};
+
+	const applyBanner = (ctx: ExtensionContext) => {
+		if (!ctx.hasUI) {
+			return;
+		}
+
+		if (!state.active) {
+			ctx.ui.setWidget(BANNER_WIDGET_KEY, undefined, {
+				placement: "aboveEditor",
+			});
+			return;
+		}
+
+		ctx.ui.setWidget(
+			BANNER_WIDGET_KEY,
+			(_tui, theme) => ({
+				invalidate: () => {},
+				render: (width: number) => {
+					const { truncateToWidth, wrapTextWithAnsi } = getPiTui();
+					const safeWidth = Math.max(1, width);
+					const activePlanFilePath = resolveActivePlanFilePath(ctx, state.planFilePath);
+					const lines = [
+						truncateToWidth(
+							`${theme.fg("warning", theme.bold(" Plan mode active"))}${theme.fg(
+								"muted",
+								"; `/plan` to exit. `/plan <location>` to move plan file.",
+							)}`,
+							safeWidth,
+						),
+						...wrapTextWithAnsi(theme.fg("dim", ` Plan file: ${activePlanFilePath}`), safeWidth),
+					];
+					return lines;
+				},
+			}),
+			{ placement: "aboveEditor" },
+		);
+	};
+
+	const setState = (ctx: ExtensionContext, nextState: PlanModeState) => {
+		state = nextState;
+		persistState();
+		syncPlanModeTools();
+		applyBanner(ctx);
+	};
+
+	const startPlanMode = (
+		ctx: ExtensionContext,
+		options: {
+			originLeafId?: string;
+			planFilePath: string;
+		},
+	) => {
+		setState(ctx, {
+			active: true,
+			lastPlanLeafId: state.lastPlanLeafId,
+			originLeafId: options.originLeafId,
+			planFilePath: options.planFilePath,
+			version: state.version,
+		});
+	};
+
+	const refresh = (ctx: ExtensionContext) => {
+		state = getLatestState(ctx);
+		syncPlanModeTools();
+		applyBanner(ctx);
+	};
+
+	return {
+		applyBanner,
+		getState: () => state,
+		refresh,
+		setState,
+		startPlanMode,
+		syncTools: syncPlanModeTools,
+	};
+}

package/types.ts

@@ -0,0 +1,36 @@
+export interface PlanModeState {
+	version: number;
+	active: boolean;
+	originLeafId?: string;
+	planFilePath?: string;
+	lastPlanLeafId?: string;
+}
+
+export interface RequestUserInputOption {
+	label: string;
+	description: string;
+}
+
+export interface RequestUserInputQuestion {
+	id: string;
+	header: string;
+	question: string;
+	options?: RequestUserInputOption[];
+}
+
+export type NormalizedRequestUserInputQuestion = Omit<RequestUserInputQuestion, "options"> & {
+	options: RequestUserInputOption[];
+};
+
+export interface RequestUserInputAnswer {
+	answers: string[];
+}
+
+export interface RequestUserInputResponse {
+	answers: Record<string, RequestUserInputAnswer>;
+}
+
+export interface RequestUserInputDetails {
+	questions: NormalizedRequestUserInputQuestion[];
+	response: RequestUserInputResponse;
+}

package/utils.ts

@@ -0,0 +1,64 @@
+import path from "node:path";
+
+import type { PlanModeState } from "./types";
+
+export const PLAN_MODE_STATE_VERSION = 1;
+
+export type { PlanModeState };
+
+export const PLAN_MODE_START_OPTIONS = ["Empty branch", "Current branch"] as const;
+export const PLAN_MODE_END_OPTIONS = ["Exit", "Exit & summarize branch"] as const;
+
+export const PLAN_MODE_SUMMARY_PROMPT = `We are switching from a planning branch back to implementation work.
+Summarize this planning branch so implementation can begin immediately.
+
+Include:
+1. Goal and scope
+2. Key decisions and assumptions
+3. Ordered implementation steps
+4. Risks, validations, and open questions
+5. Important file paths, commands, and references gathered during planning
+
+Use concise bullet points and preserve exact technical identifiers when relevant.`;
+
+export function createInactivePlanModeState(): PlanModeState {
+	return {
+		active: false,
+		version: PLAN_MODE_STATE_VERSION,
+	};
+}
+
+export function isPlanModeState(value: unknown): value is PlanModeState {
+	if (!value || typeof value !== "object") {
+		return false;
+	}
+
+	const state = value as Partial<PlanModeState>;
+	return state.version === PLAN_MODE_STATE_VERSION && typeof state.active === "boolean";
+}
+
+export function resolvePlanFilePath(cwd: string, filePath: string): string | null {
+	const trimmed = filePath.trim();
+	if (!trimmed) {
+		return null;
+	}
+	return path.resolve(cwd, trimmed);
+}
+
+export function findDuplicateId(ids: string[]): string | null {
+	const seen = new Set<string>();
+	for (const id of ids) {
+		if (seen.has(id)) {
+			return id;
+		}
+		seen.add(id);
+	}
+	return null;
+}
+
+export function buildImplementationPrefill(planPath?: string): string {
+	if (planPath) {
+		return `Plan file: ${planPath}\nImplement the approved plan in this file. Keep changes focused, update tests, and summarize what was implemented.`;
+	}
+	return "Implement the approved plan step by step. Keep changes focused, update tests, and summarize what was implemented.";
+}