@diegopetrucci/pi-annotate-last-message 0.1.9 → 0.1.11

package/README.md

@@ -22,11 +22,19 @@ Run `/annotate-last-message` from an interactive pi session. The annotation wind
 - section comments for larger chunks of the message, and
 - inline notes tied to individual lines.
 
-When you submit, the extension appends a structured planning-oriented feedback prompt to the current editor buffer. It does not auto-apply changes or rewrite the previous assistant message in place.
+The message preview renders headings, lists, blockquotes, emphasis, inline code, strikethrough, links, and fenced code while preserving the original one-based source-line coordinates. Raw HTML is displayed as text. Link destinations are shown as inert text beside the label; the window never navigates to an assistant-provided URL.
+
+The window follows the active Pi theme through `ctx.ui.theme`, including Markdown colors and dark/light appearance, with readable local fallbacks when a theme token is unavailable. Opening the window does not change Pi's host theme or settings.
+
+When you submit, the extension sends a structured planning-oriented feedback prompt directly to the agent as a follow-up message. Your existing editor text is left untouched. It does not auto-apply changes or rewrite the previous assistant message in place.
+
+## Rollback
+
+There is no runtime setting or toggle for submit behavior. To roll back the rendering/theme change, reinstall the previous package version or revert this source change and rebuild/reinstall the package; no Pi theme or host setting needs to be restored.
 
 ## Requirements
 
-- Interactive pi session with editor access.
+- Interactive pi TUI session.
 - A completed assistant message with text on the active branch.
 - Local desktop support for opening a native [Glimpse](https://github.com/mariozechner/glimpse) window.
 

package/glimpseui.d.ts

@@ -1,89 +1,98 @@
 declare module "glimpseui" {
-	import { EventEmitter } from "node:events";
+  import { EventEmitter } from "node:events";
 
-	export type FollowMode = "snap" | "spring";
-	export type CursorAnchor = "top-left" | "top-right" | "right" | "bottom-right" | "bottom-left" | "left";
+  export type FollowMode = "snap" | "spring";
+  export type CursorAnchor =
+    | "top-left"
+    | "top-right"
+    | "right"
+    | "bottom-right"
+    | "bottom-left"
+    | "left";
 
-	export interface GlimpseOpenOptions {
-		width?: number;
-		height?: number;
-		title?: string;
-		x?: number;
-		y?: number;
-		frameless?: boolean;
-		floating?: boolean;
-		transparent?: boolean;
-		clickThrough?: boolean;
-		followCursor?: boolean;
-		followMode?: FollowMode;
-		cursorAnchor?: CursorAnchor;
-		cursorOffset?: {
-			x?: number;
-			y?: number;
-		};
-		hidden?: boolean;
-		autoClose?: boolean;
-		timeout?: number;
-	}
+  export interface GlimpseOpenOptions {
+    width?: number;
+    height?: number;
+    title?: string;
+    x?: number;
+    y?: number;
+    frameless?: boolean;
+    floating?: boolean;
+    transparent?: boolean;
+    clickThrough?: boolean;
+    followCursor?: boolean;
+    followMode?: FollowMode;
+    cursorAnchor?: CursorAnchor;
+    cursorOffset?: {
+      x?: number;
+      y?: number;
+    };
+    hidden?: boolean;
+    autoClose?: boolean;
+    timeout?: number;
+  }
 
-	export interface GlimpseScreenInfo {
-		width: number;
-		height: number;
-		scaleFactor: number;
-		visibleX?: number;
-		visibleY?: number;
-		visibleWidth?: number;
-		visibleHeight?: number;
-		x?: number;
-		y?: number;
-	}
+  export interface GlimpseScreenInfo {
+    width: number;
+    height: number;
+    scaleFactor: number;
+    visibleX?: number;
+    visibleY?: number;
+    visibleWidth?: number;
+    visibleHeight?: number;
+    x?: number;
+    y?: number;
+  }
 
-	export interface GlimpseAppearanceInfo {
-		darkMode: boolean;
-		accentColor: string;
-		reduceMotion: boolean;
-		increaseContrast: boolean;
-	}
+  export interface GlimpseAppearanceInfo {
+    darkMode: boolean;
+    accentColor: string;
+    reduceMotion: boolean;
+    increaseContrast: boolean;
+  }
 
-	export interface GlimpseCursorInfo {
-		x: number;
-		y: number;
-	}
+  export interface GlimpseCursorInfo {
+    x: number;
+    y: number;
+  }
 
-	export interface GlimpseCursorTip {
-		x: number;
-		y: number;
-	}
+  export interface GlimpseCursorTip {
+    x: number;
+    y: number;
+  }
 
-	export interface GlimpseInfo {
-		screen: GlimpseScreenInfo;
-		screens: GlimpseScreenInfo[];
-		appearance: GlimpseAppearanceInfo;
-		cursor: GlimpseCursorInfo;
-		cursorTip: GlimpseCursorTip | null;
-	}
+  export interface GlimpseInfo {
+    screen: GlimpseScreenInfo;
+    screens: GlimpseScreenInfo[];
+    appearance: GlimpseAppearanceInfo;
+    cursor: GlimpseCursorInfo;
+    cursorTip: GlimpseCursorTip | null;
+  }
 
-	export class GlimpseWindow extends EventEmitter {
-		on(event: "ready", listener: (info: GlimpseInfo) => void): this;
-		on(event: "message", listener: (data: unknown) => void): this;
-		on(event: "info", listener: (info: GlimpseInfo) => void): this;
-		on(event: "closed", listener: () => void): this;
-		on(event: "error", listener: (error: Error) => void): this;
-		once(event: "ready", listener: (info: GlimpseInfo) => void): this;
-		once(event: "message", listener: (data: unknown) => void): this;
-		once(event: "info", listener: (info: GlimpseInfo) => void): this;
-		once(event: "closed", listener: () => void): this;
-		once(event: "error", listener: (error: Error) => void): this;
-		send(js: string): void;
-		setHTML(html: string): void;
-		show(options?: { title?: string }): void;
-		close(): void;
-		loadFile(path: string): void;
-		get info(): GlimpseInfo | null;
-		getInfo(): void;
-		followCursor(enabled: boolean, anchor?: CursorAnchor, mode?: FollowMode): void;
-	}
+  export class GlimpseWindow extends EventEmitter {
+    on(event: "ready", listener: (info: GlimpseInfo) => void): this;
+    on(event: "message", listener: (data: unknown) => void): this;
+    on(event: "info", listener: (info: GlimpseInfo) => void): this;
+    on(event: "closed", listener: () => void): this;
+    on(event: "error", listener: (error: Error) => void): this;
+    once(event: "ready", listener: (info: GlimpseInfo) => void): this;
+    once(event: "message", listener: (data: unknown) => void): this;
+    once(event: "info", listener: (info: GlimpseInfo) => void): this;
+    once(event: "closed", listener: () => void): this;
+    once(event: "error", listener: (error: Error) => void): this;
+    send(js: string): void;
+    setHTML(html: string): void;
+    show(options?: { title?: string }): void;
+    close(): void;
+    loadFile(path: string): void;
+    get info(): GlimpseInfo | null;
+    getInfo(): void;
+    followCursor(enabled: boolean, anchor?: CursorAnchor, mode?: FollowMode): void;
+  }
 
-	export function open(html: string, options?: GlimpseOpenOptions): GlimpseWindow;
-	export function prompt<T = unknown>(html: string, options?: GlimpseOpenOptions): Promise<T | null>;
+  export function open(html: string, options?: GlimpseOpenOptions): GlimpseWindow;
+  export function prompt<T = unknown>(
+    html: string,
+    options?: GlimpseOpenOptions,
+  ): Promise<T | null>;
 }

package/index.ts

@@ -3,189 +3,233 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-c
 import { openQuietGlimpse, type QuietGlimpseWindow } from "./quiet-glimpse.js";
 import { composeAnnotateLastMessagePrompt, hasAnnotateLastMessageFeedback } from "./prompt.js";
 import { findLastAssistantMessage } from "./session.js";
-import type { AnnotateLastMessageCancelPayload, AnnotateLastMessageSubmitPayload, AnnotateLastMessageWindowMessage, LastAssistantMessageData } from "./types.js";
+import type {
+  AnnotateLastMessageCancelPayload,
+  AnnotateLastMessageInlineComment,
+  AnnotateLastMessageSectionComment,
+  AnnotateLastMessageSubmitPayload,
+  AnnotateLastMessageWindowMessage,
+  LastAssistantMessageData,
+} from "./types.js";
 import { buildAnnotateLastMessageHtml } from "./ui.js";
 
-function isSubmitPayload(value: unknown): value is AnnotateLastMessageSubmitPayload {
-	return typeof value === "object" && value != null && "type" in value && value.type === "submit";
+function isInlineComment(value: unknown): value is AnnotateLastMessageInlineComment {
+  return (
+    typeof value === "object" &&
+    value != null &&
+    "line" in value &&
+    typeof value.line === "number" &&
+    Number.isInteger(value.line) &&
+    value.line > 0 &&
+    "body" in value &&
+    typeof value.body === "string"
+  );
 }
 
-function isCancelPayload(value: unknown): value is AnnotateLastMessageCancelPayload {
-	return typeof value === "object" && value != null && "type" in value && value.type === "cancel";
+function isSectionComment(value: unknown): value is AnnotateLastMessageSectionComment {
+  return (
+    typeof value === "object" &&
+    value != null &&
+    "sectionId" in value &&
+    typeof value.sectionId === "string" &&
+    "body" in value &&
+    typeof value.body === "string"
+  );
+}
+
+function isSubmitPayload(value: unknown): value is AnnotateLastMessageSubmitPayload {
+  return (
+    typeof value === "object" &&
+    value != null &&
+    "type" in value &&
+    value.type === "submit" &&
+    "overallComment" in value &&
+    typeof value.overallComment === "string" &&
+    "inlineComments" in value &&
+    Array.isArray(value.inlineComments) &&
+    value.inlineComments.every(isInlineComment) &&
+    "sectionComments" in value &&
+    Array.isArray(value.sectionComments) &&
+    value.sectionComments.every(isSectionComment)
+  );
 }
 
-function appendPrompt(ctx: ExtensionCommandContext, prompt: string): void {
-	const prefix = ctx.ui.getEditorText().trim().length > 0 ? "\n\n" : "";
-	ctx.ui.pasteToEditor(`${prefix}${prompt}`);
+function isCancelPayload(value: unknown): value is AnnotateLastMessageCancelPayload {
+  return typeof value === "object" && value != null && "type" in value && value.type === "cancel";
 }
 
-export function registerAnnotateLastMessageCommand(pi: ExtensionAPI): void {
-	let activeWindow: QuietGlimpseWindow | null = null;
-	let annotationOpening = false;
-	let annotationAttempt = 0;
-	const suppressedWindows = new WeakSet<QuietGlimpseWindow>();
-
-	function closeActiveWindow(options: { suppressResults?: boolean } = {}): void {
-		annotationAttempt += 1;
-		const windowToClose = activeWindow;
-		activeWindow = null;
-		if (windowToClose == null) return;
-		if (options.suppressResults) {
-			suppressedWindows.add(windowToClose);
-		}
-		try {
-			windowToClose.close();
-		} catch {
-			// Ignore races when the native window is already closing.
-		}
-	}
-
-	async function openAnnotationWindow(ctx: ExtensionCommandContext): Promise<void> {
-		if (ctx.mode !== "tui") {
-			ctx.ui.notify("annotate-last-message requires interactive mode.", "error");
-			return;
-		}
-		if (annotationOpening || activeWindow != null) {
-			ctx.ui.notify("A last-message annotation window is already open.", "warning");
-			return;
-		}
-
-		const messageResult = findLastAssistantMessage(ctx.sessionManager.getBranch());
-		if (!messageResult.ok) {
-			ctx.ui.notify(messageResult.message, "error");
-			return;
-		}
-
-		const messageData = messageResult.data;
-		annotationOpening = true;
-		const attempt = ++annotationAttempt;
-
-		try {
-			const html = buildAnnotateLastMessageHtml(messageData);
-			const window = await openQuietGlimpse(html, {
-				width: 1440,
-				height: 980,
-				title: "annotate last message",
-			});
-			if (attempt !== annotationAttempt) {
-				suppressedWindows.add(window);
-				window.close();
-				return;
-			}
-			activeWindow = window;
-			if (window.failure != null) throw window.failure;
-			if (window.closed) throw new Error("Glimpse closed while the annotation window was starting.");
-
-			const terminalMessagePromise = new Promise<AnnotateLastMessageSubmitPayload | AnnotateLastMessageCancelPayload | null>(
-				(resolve, reject) => {
-					let settled = false;
-					let closeTimer: ReturnType<typeof setTimeout> | null = null;
-
-					const requestWindowClose = (): void => {
-						try {
-							window.close();
-						} catch {
-							// Ignore races when the native process has already exited.
-						}
-					};
-
-					const cleanup = (): void => {
-						if (closeTimer != null) {
-							clearTimeout(closeTimer);
-							closeTimer = null;
-						}
-						window.removeListener("message", onMessage);
-						window.removeListener("closed", onClosed);
-						window.removeListener("error", onError);
-						if (activeWindow === window) {
-							activeWindow = null;
-						}
-					};
-
-					const settle = (value: AnnotateLastMessageWindowMessage | null): void => {
-						if (settled) return;
-						settled = true;
-						cleanup();
-						resolve(value);
-					};
-
-					const onMessage = (data: unknown): void => {
-						if (isSubmitPayload(data) || isCancelPayload(data)) {
-							requestWindowClose();
-							settle(data);
-						}
-					};
-
-					const onClosed = (): void => {
-						if (settled || closeTimer != null) return;
-						closeTimer = setTimeout(() => {
-							closeTimer = null;
-							settle(null);
-						}, 250);
-					};
-
-					const onError = (error: Error): void => {
-						if (settled) return;
-						settled = true;
-						requestWindowClose();
-						cleanup();
-						reject(error);
-					};
-
-					window.on("message", onMessage);
-					window.on("closed", onClosed);
-					window.on("error", onError);
-					if (window.failure != null) onError(window.failure);
-					else if (window.closed) onClosed();
-				},
-			);
-
-			void (async (windowMessageSource: QuietGlimpseWindow, sourceData: LastAssistantMessageData) => {
-				try {
-					const result = await terminalMessagePromise;
-					if (suppressedWindows.has(windowMessageSource)) return;
-					if (result == null) return;
-					if (result.type === "cancel") {
-						ctx.ui.notify("Annotation cancelled.", "info");
-						return;
-					}
-					if (!hasAnnotateLastMessageFeedback(result)) {
-						ctx.ui.notify("No annotation feedback submitted.", "info");
-						return;
-					}
-
-					const prompt = composeAnnotateLastMessagePrompt(sourceData, result);
-					appendPrompt(ctx, prompt);
-					ctx.ui.notify("Appended annotation feedback to the editor.", "info");
-				} catch (error) {
-					if (suppressedWindows.has(windowMessageSource)) return;
-					const message = error instanceof Error ? error.message : String(error);
-					ctx.ui.notify(`Annotation failed: ${message}`, "error");
-				}
-			})(window, messageData);
-
-			ctx.ui.notify("Opened native annotation window.", "info");
-		} catch (error) {
-			closeActiveWindow({ suppressResults: true });
-			const message = error instanceof Error ? error.message : String(error);
-			ctx.ui.notify(`Annotation failed: ${message}`, "error");
-		} finally {
-			annotationOpening = false;
-		}
-	}
-
-	pi.registerCommand("annotate-last-message", {
-		description: "Open a native annotation window for the latest assistant message",
-		handler: async (_args, ctx) => {
-			await openAnnotationWindow(ctx);
-		},
-	});
-
-	pi.on("session_shutdown", async () => {
-		closeActiveWindow({ suppressResults: true });
-	});
+function registerAnnotateLastMessageCommand(pi: ExtensionAPI): void {
+  let activeWindow: QuietGlimpseWindow | null = null;
+  let annotationOpening = false;
+  let annotationAttempt = 0;
+  const suppressedWindows = new WeakSet<QuietGlimpseWindow>();
+
+  function closeActiveWindow(options: { suppressResults?: boolean } = {}): void {
+    annotationAttempt += 1;
+    const windowToClose = activeWindow;
+    activeWindow = null;
+    if (windowToClose == null) return;
+    if (options.suppressResults) {
+      suppressedWindows.add(windowToClose);
+    }
+    try {
+      windowToClose.close();
+    } catch {
+      // Ignore races when the native window is already closing.
+    }
+  }
+
+  async function openAnnotationWindow(ctx: ExtensionCommandContext): Promise<void> {
+    if (ctx.mode !== "tui") {
+      ctx.ui.notify("annotate-last-message requires interactive mode.", "error");
+      return;
+    }
+    if (annotationOpening || activeWindow != null) {
+      ctx.ui.notify("A last-message annotation window is already open.", "warning");
+      return;
+    }
+
+    const messageResult = findLastAssistantMessage(ctx.sessionManager.getBranch());
+    if (!messageResult.ok) {
+      ctx.ui.notify(messageResult.message, "error");
+      return;
+    }
+
+    const messageData = messageResult.data;
+    annotationOpening = true;
+    const attempt = ++annotationAttempt;
+
+    try {
+      const html = buildAnnotateLastMessageHtml(messageData, ctx.ui.theme);
+      const window = await openQuietGlimpse(html, {
+        width: 1440,
+        height: 980,
+        title: "annotate last message",
+      });
+      if (attempt !== annotationAttempt) {
+        suppressedWindows.add(window);
+        window.close();
+        return;
+      }
+      activeWindow = window;
+      if (window.failure != null) throw window.failure;
+      if (window.closed)
+        throw new Error("Glimpse closed while the annotation window was starting.");
+
+      const terminalMessagePromise = new Promise<
+        AnnotateLastMessageSubmitPayload | AnnotateLastMessageCancelPayload | null
+      >((resolve, reject) => {
+        let settled = false;
+        let closeTimer: ReturnType<typeof setTimeout> | null = null;
+
+        const requestWindowClose = (): void => {
+          try {
+            window.close();
+          } catch {
+            // Ignore races when the native process has already exited.
+          }
+        };
+
+        const cleanup = (): void => {
+          if (closeTimer != null) {
+            clearTimeout(closeTimer);
+            closeTimer = null;
+          }
+          window.removeListener("message", onMessage);
+          window.removeListener("closed", onClosed);
+          window.removeListener("error", onError);
+          if (activeWindow === window) {
+            activeWindow = null;
+          }
+        };
+
+        const settle = (value: AnnotateLastMessageWindowMessage | null): void => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          resolve(value);
+        };
+
+        const onMessage = (data: unknown): void => {
+          if (isSubmitPayload(data) || isCancelPayload(data)) {
+            settle(data);
+            requestWindowClose();
+          }
+        };
+
+        const onClosed = (): void => {
+          if (settled || closeTimer != null) return;
+          closeTimer = setTimeout(() => {
+            closeTimer = null;
+            settle(null);
+          }, 250);
+        };
+
+        const onError = (error: Error): void => {
+          if (settled) return;
+          settled = true;
+          requestWindowClose();
+          cleanup();
+          reject(error);
+        };
+
+        window.on("message", onMessage);
+        window.on("closed", onClosed);
+        window.on("error", onError);
+        if (window.failure != null) onError(window.failure);
+        else if (window.closed) onClosed();
+      });
+
+      void (async (
+        windowMessageSource: QuietGlimpseWindow,
+        sourceData: LastAssistantMessageData,
+      ) => {
+        try {
+          const result = await terminalMessagePromise;
+          if (suppressedWindows.has(windowMessageSource) || attempt !== annotationAttempt) return;
+          if (result == null) return;
+          if (result.type === "cancel") {
+            ctx.ui.notify("Annotation cancelled.", "info");
+            return;
+          }
+          if (!hasAnnotateLastMessageFeedback(result)) {
+            ctx.ui.notify("No annotation feedback submitted.", "info");
+            return;
+          }
+
+          const prompt = composeAnnotateLastMessagePrompt(sourceData, result);
+          pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+          ctx.ui.notify("Annotation feedback sent to the agent.", "info");
+        } catch (error) {
+          if (suppressedWindows.has(windowMessageSource) || attempt !== annotationAttempt) return;
+          const message = error instanceof Error ? error.message : String(error);
+          ctx.ui.notify(`Annotation failed: ${message}`, "error");
+        }
+      })(window, messageData);
+
+      ctx.ui.notify("Opened native annotation window.", "info");
+    } catch (error) {
+      if (attempt !== annotationAttempt) return;
+      closeActiveWindow({ suppressResults: true });
+      const message = error instanceof Error ? error.message : String(error);
+      ctx.ui.notify(`Annotation failed: ${message}`, "error");
+    } finally {
+      annotationOpening = false;
+    }
+  }
+
+  pi.registerCommand("annotate-last-message", {
+    description: "Open a native annotation window for the latest assistant message",
+    handler: async (_args, ctx) => {
+      await openAnnotationWindow(ctx);
+    },
+  });
+
+  pi.on("session_shutdown", async () => {
+    closeActiveWindow({ suppressResults: true });
+  });
 }
 
 export default function (pi: ExtensionAPI): void {
-	registerAnnotateLastMessageCommand(pi);
+  registerAnnotateLastMessageCommand(pi);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-annotate-last-message",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "A standalone pi extension that adds /annotate-last-message, a native Glimpse UI for annotating the latest assistant reply.",
   "keywords": [
     "pi-package",
@@ -20,6 +20,7 @@
     "prompt.ts",
     "quiet-glimpse.ts",
     "session.ts",
+    "theme.ts",
     "types.ts",
     "ui.ts",
     "web",