@plannotator/pi-extension 0.16.4 → 0.16.6

package/plannotator-browser.ts

@@ -0,0 +1,250 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+	getGitContext,
+	runGitDiff,
+	startAnnotateServer,
+	startPlanReviewServer,
+	startReviewServer,
+	type DiffType,
+} from "./server.js";
+import { openBrowser } from "./server/network.js";
+
+export type AnnotateMode = "annotate" | "annotate-folder" | "annotate-last";
+export interface PlanReviewDecision {
+	approved: boolean;
+	feedback?: string;
+	savedPath?: string;
+	agentSwitch?: string;
+	permissionMode?: string;
+}
+
+export interface PlanReviewBrowserSession {
+	reviewId: string;
+	url: string;
+	waitForDecision: () => Promise<PlanReviewDecision>;
+	onDecision: (listener: (result: PlanReviewDecision) => void | Promise<void>) => () => void;
+	stop: () => void;
+}
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+let planHtmlContent = "";
+let reviewHtmlContent = "";
+
+try {
+	planHtmlContent = readFileSync(resolve(__dirname, "plannotator.html"), "utf-8");
+} catch {
+	// built assets unavailable
+}
+
+try {
+	reviewHtmlContent = readFileSync(resolve(__dirname, "review-editor.html"), "utf-8");
+} catch {
+	// built assets unavailable
+}
+
+function delay(ms: number): Promise<void> {
+	return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+
+export function hasPlanBrowserHtml(): boolean {
+	return Boolean(planHtmlContent);
+}
+
+export function hasReviewBrowserHtml(): boolean {
+	return Boolean(reviewHtmlContent);
+}
+
+export function getStartupErrorMessage(err: unknown): string {
+	return err instanceof Error ? err.message : "Unknown error";
+}
+
+type AssistantTextBlock = { type?: string; text?: string };
+
+type AssistantMessageLike = { role?: unknown; content?: unknown };
+
+function isAssistantMessage(message: AssistantMessageLike): message is { role: "assistant"; content: AssistantTextBlock[] } {
+	return message.role === "assistant" && Array.isArray(message.content);
+}
+
+function getTextContent(message: { content: AssistantTextBlock[] }): string {
+	return message.content
+		.filter((block): block is { type: "text"; text: string } => block.type === "text")
+		.map((block) => block.text)
+		.join("\n");
+}
+
+export async function getLastAssistantMessageText(ctx: ExtensionContext): Promise<string | null> {
+	const entries = ctx.sessionManager.getEntries();
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const entry = entries[i] as { type: string; message?: AssistantMessageLike };
+		if (entry.type === "message" && entry.message && isAssistantMessage(entry.message)) {
+			const text = getTextContent(entry.message);
+			if (text.trim()) return text;
+		}
+	}
+	return null;
+}
+
+function openBrowserForServer(serverUrl: string, ctx: ExtensionContext): void {
+	const browserResult = openBrowser(serverUrl);
+	if (browserResult.isRemote) {
+		ctx.ui.notify(`Remote session. Open manually: ${browserResult.url}`, "info");
+	} else if (!browserResult.opened) {
+		ctx.ui.notify(`Open this URL to review: ${serverUrl}`, "info");
+	}
+}
+
+async function openBrowserAndWait<T>(
+	server: { url: string; stop: () => void },
+	ctx: ExtensionContext,
+	waitForResult: () => Promise<T>,
+): Promise<T> {
+	openBrowserForServer(server.url, ctx);
+
+	const result = await waitForResult();
+	await delay(1500);
+	server.stop();
+	return result;
+}
+
+export async function startPlanReviewBrowserSession(
+	ctx: ExtensionContext,
+	planContent: string,
+): Promise<PlanReviewBrowserSession> {
+	if (!ctx.hasUI || !planHtmlContent) {
+		throw new Error("Plannotator browser review is unavailable in this session.");
+	}
+
+	const server = await startPlanReviewServer({
+		plan: planContent,
+		htmlContent: planHtmlContent,
+		origin: "pi",
+		sharingEnabled: process.env.PLANNOTATOR_SHARE !== "disabled",
+		shareBaseUrl: process.env.PLANNOTATOR_SHARE_URL || undefined,
+		pasteApiUrl: process.env.PLANNOTATOR_PASTE_URL || undefined,
+	});
+
+	openBrowserForServer(server.url, ctx);
+	server.onDecision(() => {
+		setTimeout(() => server.stop(), 1500);
+	});
+
+	return {
+		reviewId: server.reviewId,
+		url: server.url,
+		waitForDecision: server.waitForDecision,
+		onDecision: server.onDecision,
+		stop: server.stop,
+	};
+}
+
+export async function openPlanReviewBrowser(
+	ctx: ExtensionContext,
+	planContent: string,
+): Promise<PlanReviewDecision> {
+	const session = await startPlanReviewBrowserSession(ctx, planContent);
+	return session.waitForDecision();
+}
+
+export async function openCodeReview(
+	ctx: ExtensionContext,
+	options: { cwd?: string; defaultBranch?: string; diffType?: DiffType } = {},
+): Promise<{ approved: boolean; feedback?: string; annotations?: unknown[]; agentSwitch?: string }> {
+	if (!ctx.hasUI || !reviewHtmlContent) {
+		throw new Error("Plannotator code review browser is unavailable in this session.");
+	}
+
+	const cwd = options.cwd ?? ctx.cwd;
+	const gitCtx = await getGitContext(cwd);
+	const defaultBranch = options.defaultBranch ?? gitCtx.defaultBranch;
+	const diffType: DiffType = options.diffType ?? "uncommitted";
+	const { patch: rawPatch, label: gitRef, error } = await runGitDiff(diffType, defaultBranch, cwd);
+	const server = await startReviewServer({
+		rawPatch,
+		gitRef,
+		error,
+		origin: "pi",
+		diffType,
+		gitContext: gitCtx,
+		htmlContent: reviewHtmlContent,
+		sharingEnabled: process.env.PLANNOTATOR_SHARE !== "disabled",
+		shareBaseUrl: process.env.PLANNOTATOR_SHARE_URL || undefined,
+	});
+
+	return openBrowserAndWait(server, ctx, server.waitForDecision);
+}
+
+export async function openMarkdownAnnotation(
+	ctx: ExtensionContext,
+	filePath: string,
+	markdown: string,
+	mode: AnnotateMode,
+	folderPath?: string,
+): Promise<{ feedback: string }> {
+	if (!ctx.hasUI || !planHtmlContent) {
+		throw new Error("Plannotator annotation browser is unavailable in this session.");
+	}
+
+	let resolvedMarkdown = markdown;
+	if (!resolvedMarkdown.trim() && existsSync(filePath)) {
+		try {
+			const fileStat = statSync(filePath);
+			if (!fileStat.isDirectory()) {
+				resolvedMarkdown = readFileSync(filePath, "utf-8");
+			}
+		} catch {
+			// fall back to provided markdown
+		}
+	}
+
+	const server = await startAnnotateServer({
+		markdown: resolvedMarkdown,
+		filePath,
+		origin: "pi",
+		mode,
+		folderPath,
+		htmlContent: planHtmlContent,
+		sharingEnabled: process.env.PLANNOTATOR_SHARE !== "disabled",
+		shareBaseUrl: process.env.PLANNOTATOR_SHARE_URL || undefined,
+		pasteApiUrl: process.env.PLANNOTATOR_PASTE_URL || undefined,
+	});
+
+	return openBrowserAndWait(server, ctx, server.waitForDecision);
+}
+
+export async function openLastMessageAnnotation(
+	ctx: ExtensionContext,
+	lastText: string,
+): Promise<{ feedback: string }> {
+	return openMarkdownAnnotation(ctx, "last-message", lastText, "annotate-last");
+}
+
+export async function openArchiveBrowserAction(
+	ctx: ExtensionContext,
+	customPlanPath?: string,
+): Promise<{ opened: boolean }> {
+	if (!ctx.hasUI || !planHtmlContent) {
+		throw new Error("Plannotator archive browser is unavailable in this session.");
+	}
+
+	const server = await startPlanReviewServer({
+		plan: "",
+		htmlContent: planHtmlContent,
+		origin: "pi",
+		mode: "archive",
+		customPlanPath,
+		sharingEnabled: process.env.PLANNOTATOR_SHARE !== "disabled",
+		shareBaseUrl: process.env.PLANNOTATOR_SHARE_URL || undefined,
+		pasteApiUrl: process.env.PLANNOTATOR_PASTE_URL || undefined,
+	});
+
+	return openBrowserAndWait(server, ctx, async () => {
+		if (server.waitForDone) {
+			await server.waitForDone();
+		}
+		return { opened: true };
+	});
+}

package/plannotator-events.ts

@@ -0,0 +1,316 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { DiffType } from "./server.js";
+import {
+	getLastAssistantMessageText,
+	getStartupErrorMessage,
+	openArchiveBrowserAction,
+	openCodeReview,
+	openLastMessageAnnotation,
+	openMarkdownAnnotation,
+	startPlanReviewBrowserSession,
+} from "./plannotator-browser.js";
+
+export const PLANNOTATOR_REQUEST_CHANNEL = "plannotator:request" as const;
+export const PLANNOTATOR_REVIEW_RESULT_CHANNEL = "plannotator:review-result" as const;
+export const PLANNOTATOR_TIMEOUT_MS = 5_000;
+
+export type PlannotatorAction =
+	| "plan-review"
+	| "review-status"
+	| "code-review"
+	| "annotate"
+	| "annotate-last"
+	| "archive";
+
+export interface PlannotatorHandledResponse<T> {
+	status: "handled";
+	result: T;
+}
+
+export interface PlannotatorUnavailableResponse {
+	status: "unavailable";
+	error?: string;
+}
+
+export interface PlannotatorErrorResponse {
+	status: "error";
+	error: string;
+}
+
+export type PlannotatorResponse<T> =
+	| PlannotatorHandledResponse<T>
+	| PlannotatorUnavailableResponse
+	| PlannotatorErrorResponse;
+
+export interface PlannotatorRequestBase<A extends PlannotatorAction, P, R> {
+	requestId: string;
+	action: A;
+	payload: P;
+	respond: (response: PlannotatorResponse<R>) => void;
+}
+
+export interface PlannotatorPlanReviewPayload {
+	planFilePath?: string;
+	planContent: string;
+	origin?: string;
+}
+
+export interface PlannotatorPlanReviewStartResult {
+	status: "pending";
+	reviewId: string;
+}
+
+export interface PlannotatorReviewResultEvent {
+	reviewId: string;
+	approved: boolean;
+	feedback?: string;
+	savedPath?: string;
+	agentSwitch?: string;
+	permissionMode?: string;
+}
+
+export interface PlannotatorReviewStatusPayload {
+	reviewId: string;
+}
+
+export type PlannotatorReviewStatusResult =
+	| { status: "pending" }
+	| ({ status: "completed" } & PlannotatorReviewResultEvent)
+	| { status: "missing" };
+
+export interface PlannotatorCodeReviewPayload {
+	diffType?: DiffType;
+	defaultBranch?: string;
+	cwd?: string;
+}
+
+export interface PlannotatorCodeReviewResult {
+	approved: boolean;
+	feedback?: string;
+	annotations?: unknown[];
+	agentSwitch?: string;
+}
+
+export interface PlannotatorAnnotatePayload {
+	filePath: string;
+	markdown?: string;
+	mode?: "annotate" | "annotate-folder" | "annotate-last";
+	folderPath?: string;
+}
+
+export interface PlannotatorAnnotationResult {
+	feedback: string;
+}
+
+export interface PlannotatorArchivePayload {
+	customPlanPath?: string;
+}
+
+export interface PlannotatorArchiveResult {
+	opened: boolean;
+}
+
+export type PlannotatorRequestMap = {
+	"plan-review": PlannotatorRequestBase<"plan-review", PlannotatorPlanReviewPayload, PlannotatorPlanReviewStartResult>;
+	"review-status": PlannotatorRequestBase<"review-status", PlannotatorReviewStatusPayload, PlannotatorReviewStatusResult>;
+	"code-review": PlannotatorRequestBase<"code-review", PlannotatorCodeReviewPayload, PlannotatorCodeReviewResult>;
+	annotate: PlannotatorRequestBase<"annotate", PlannotatorAnnotatePayload, PlannotatorAnnotationResult>;
+	"annotate-last": PlannotatorRequestBase<"annotate-last", PlannotatorAnnotatePayload, PlannotatorAnnotationResult>;
+	archive: PlannotatorRequestBase<"archive", PlannotatorArchivePayload, PlannotatorArchiveResult>;
+};
+export type PlannotatorRequest = PlannotatorRequestMap[PlannotatorAction];
+export type PlannotatorResponseMap = {
+	"plan-review": PlannotatorResponse<PlannotatorPlanReviewStartResult>;
+	"review-status": PlannotatorResponse<PlannotatorReviewStatusResult>;
+	"code-review": PlannotatorResponse<PlannotatorCodeReviewResult>;
+	annotate: PlannotatorResponse<PlannotatorAnnotationResult>;
+	"annotate-last": PlannotatorResponse<PlannotatorAnnotationResult>;
+	archive: PlannotatorResponse<PlannotatorArchiveResult>;
+};
+function isPlannotatorAction(value: unknown): value is PlannotatorAction {
+	return (
+		value === "plan-review" ||
+		value === "review-status" ||
+		value === "code-review" ||
+		value === "annotate" ||
+		value === "annotate-last" ||
+		value === "archive"
+	);
+}
+
+const REVIEW_STATUS_PATH = join(homedir(), ".pi", "plannotator-review-status.json");
+
+type StoredReviewStatus = Record<string, PlannotatorReviewStatusResult>;
+
+function readStoredReviewStatuses(): StoredReviewStatus {
+	try {
+		if (!existsSync(REVIEW_STATUS_PATH)) return {};
+		const raw = readFileSync(REVIEW_STATUS_PATH, "utf-8");
+		const parsed = JSON.parse(raw) as StoredReviewStatus;
+		return parsed && typeof parsed === "object" ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+
+function writeStoredReviewStatuses(statuses: StoredReviewStatus): void {
+	mkdirSync(dirname(REVIEW_STATUS_PATH), { recursive: true });
+	writeFileSync(REVIEW_STATUS_PATH, JSON.stringify(statuses, null, 2));
+}
+
+function setStoredReviewStatus(reviewId: string, status: PlannotatorReviewStatusResult): void {
+	const statuses = readStoredReviewStatuses();
+	statuses[reviewId] = status;
+	writeStoredReviewStatuses(statuses);
+}
+
+function getStoredReviewStatus(reviewId: string): PlannotatorReviewStatusResult {
+	return readStoredReviewStatuses()[reviewId] ?? { status: "missing" };
+}
+
+function createActiveSessionContext() {
+	let currentCtx: ExtensionContext | undefined;
+
+	return {
+		set(ctx: ExtensionContext): void {
+			currentCtx = ctx;
+		},
+		clear(): void {
+			currentCtx = undefined;
+		},
+		get(): ExtensionContext | undefined {
+			return currentCtx;
+		},
+	};
+}
+
+export function registerPlannotatorEventListeners(pi: ExtensionAPI): void {
+	const activeSessionContext = createActiveSessionContext();
+
+	// Plannotator event requests are handled against the latest active session.
+	// The active context is intentionally session-scoped and replaced on each session_start.
+	pi.on("session_start", async (_event, ctx) => {
+		activeSessionContext.set(ctx);
+	});
+	pi.events.on(PLANNOTATOR_REQUEST_CHANNEL, async (data) => {
+		const request = data as Partial<PlannotatorRequest> | null;
+		const ctx = activeSessionContext.get();
+
+		if (!request || typeof request.respond !== "function" || !isPlannotatorAction(request.action)) {
+			return;
+		}
+
+		try {
+			if (request.action === "review-status") {
+				const reviewId = request.payload?.reviewId;
+				if (typeof reviewId !== "string" || !reviewId.trim()) {
+					request.respond({ status: "error", error: "Missing reviewId for review-status request." });
+					return;
+				}
+				request.respond({ status: "handled", result: getStoredReviewStatus(reviewId) });
+				return;
+			}
+
+			if (!ctx) {
+				request.respond({ status: "unavailable", error: "Plannotator context is not ready yet." });
+				return;
+			}
+
+			switch (request.action) {
+				case "plan-review": {
+					const planContent = request.payload?.planContent;
+					if (typeof planContent !== "string" || !planContent.trim()) {
+						request.respond({ status: "error", error: "Missing planContent for plan-review request." });
+						return;
+					}
+					const session = await startPlanReviewBrowserSession(ctx, planContent);
+					setStoredReviewStatus(session.reviewId, { status: "pending" });
+					session.onDecision((result) => {
+						const reviewResult = {
+							reviewId: session.reviewId,
+							approved: result.approved,
+							feedback: result.feedback,
+							savedPath: result.savedPath,
+							agentSwitch: result.agentSwitch,
+							permissionMode: result.permissionMode,
+						} satisfies PlannotatorReviewResultEvent;
+						setStoredReviewStatus(session.reviewId, { status: "completed", ...reviewResult });
+						pi.events.emit(PLANNOTATOR_REVIEW_RESULT_CHANNEL, reviewResult);
+					});
+					request.respond({
+						status: "handled",
+						result: {
+							status: "pending",
+							reviewId: session.reviewId,
+						},
+					});
+					return;
+				}
+				case "code-review": {
+					const result = await openCodeReview(ctx, {
+						cwd: request.payload?.cwd,
+						defaultBranch: request.payload?.defaultBranch,
+						diffType: request.payload?.diffType,
+					});
+					request.respond({ status: "handled", result });
+					return;
+				}
+				case "annotate": {
+					const payload = request.payload;
+					if (!payload?.filePath) {
+						request.respond({ status: "error", error: "Missing filePath for annotate request." });
+						return;
+					}
+					const result = await openMarkdownAnnotation(
+						ctx,
+						payload.filePath,
+						payload.markdown ?? "",
+						payload.mode ?? "annotate",
+						payload.folderPath,
+					);
+					request.respond({ status: "handled", result });
+					return;
+				}
+				case "annotate-last": {
+					const payload = request.payload;
+					const lastText = payload?.markdown?.trim() ? payload.markdown : await getLastAssistantMessageText(ctx);
+					if (!lastText) {
+						request.respond({ status: "unavailable", error: "No assistant message found in session." });
+						return;
+					}
+					const result = await openLastMessageAnnotation(ctx, lastText);
+					request.respond({ status: "handled", result });
+					return;
+				}
+				case "archive": {
+					const result = await openArchiveBrowserAction(ctx, request.payload?.customPlanPath);
+					request.respond({ status: "handled", result });
+					return;
+				}
+			}
+		} catch (err) {
+			const message = getStartupErrorMessage(err);
+			if (/unavailable|not available/i.test(message)) {
+				request.respond({ status: "unavailable", error: message });
+				return;
+			}
+			request.respond({ status: "error", error: message });
+		}
+	});
+}
+
+export {
+	getLastAssistantMessageText,
+	hasPlanBrowserHtml,
+	hasReviewBrowserHtml,
+	getStartupErrorMessage,
+	openArchiveBrowserAction,
+	openCodeReview,
+	openLastMessageAnnotation,
+	openMarkdownAnnotation,
+	openPlanReviewBrowser,
+	startPlanReviewBrowserSession,
+} from "./plannotator-browser.js";