@diegopetrucci/pi-extensions 0.1.74 → 0.1.76

package/extensions/annotate-last-message/quiet-glimpse.ts

@@ -7,173 +7,179 @@ import { createInterface } from "node:readline";
 import type { GlimpseOpenOptions } from "glimpseui";
 
 interface NativeHostInfo {
-	path: string;
-	extraArgs?: string[];
-	buildHint?: string;
+  path: string;
+  extraArgs?: string[];
+  buildHint?: string;
 }
 
 interface GlimpseProtocolMessage {
-	type?: string;
-	data?: unknown;
-	screen?: unknown;
-	screens?: unknown;
-	appearance?: unknown;
-	cursor?: unknown;
-	cursorTip?: unknown;
+  type?: string;
+  data?: unknown;
+  screen?: unknown;
+  screens?: unknown;
+  appearance?: unknown;
+  cursor?: unknown;
+  cursorTip?: unknown;
 }
 
 export interface QuietGlimpseWindow {
-	readonly closed: boolean;
-	readonly failure: Error | null;
-	on(event: "message", listener: (data: unknown) => void): this;
-	on(event: "closed", listener: () => void): this;
-	on(event: "error", listener: (error: Error) => void): this;
-	removeListener(event: "message", listener: (data: unknown) => void): this;
-	removeListener(event: "closed", listener: () => void): this;
-	removeListener(event: "error", listener: (error: Error) => void): this;
-	send(js: string): void;
-	close(): void;
+  readonly closed: boolean;
+  readonly failure: Error | null;
+  on(event: "message", listener: (data: unknown) => void): this;
+  on(event: "closed", listener: () => void): this;
+  on(event: "error", listener: (error: Error) => void): this;
+  removeListener(event: "message", listener: (data: unknown) => void): this;
+  removeListener(event: "closed", listener: () => void): this;
+  removeListener(event: "error", listener: (error: Error) => void): this;
+  send(js: string): void;
+  close(): void;
 }
 
 class QuietGlimpseWindowImpl extends EventEmitter implements QuietGlimpseWindow {
-	#proc: ChildProcessWithoutNullStreams;
-	#closed = false;
-	#pendingHTML: string | null;
-	#stderr = "";
-	#failure: Error | null = null;
-
-	constructor(proc: ChildProcessWithoutNullStreams, initialHTML: string) {
-		super();
-		this.#proc = proc;
-		this.#pendingHTML = initialHTML;
-		// EventEmitter treats an unobserved `error` as fatal. Keep a permanent
-		// fallback while callers attach and detach their lifecycle listeners.
-		this.on("error", () => {});
-
-		proc.stdin.on("error", () => {});
-		proc.stderr.on("data", (chunk) => {
-			this.#stderr += chunk.toString();
-		});
-
-		const rl = createInterface({ input: proc.stdout, crlfDelay: Infinity });
-		rl.on("line", (line) => {
-			let parsed: unknown;
-			try {
-				parsed = JSON.parse(line);
-			} catch {
-				this.#reportError(new Error(`Malformed glimpse protocol line: ${line}`));
-				return;
-			}
-			if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return;
-			const message = parsed as GlimpseProtocolMessage;
-
-			switch (message.type) {
-				case "ready":
-					if (this.#pendingHTML != null) {
-						this.setHTML(this.#pendingHTML);
-						this.#pendingHTML = null;
-					}
-					break;
-				case "message":
-					this.emit("message", message.data);
-					break;
-				case "closed":
-					this.#markClosed();
-					break;
-				default:
-					break;
-			}
-		});
-
-		proc.on("error", (error) => this.#reportError(error));
-		proc.on("exit", (code, signal) => {
-			const stderr = this.#stderr.trim();
-			const failed = signal != null || (code != null && code !== 0);
-			if (!this.#closed && failed) {
-				const message = stderr || `Glimpse process exited abnormally (code: ${code}, signal: ${signal}).`;
-				this.#reportError(new Error(message));
-			}
-			this.#markClosed();
-		});
-		// Spawn failures can emit `error` and then `close` without `exit`.
-		proc.on("close", () => this.#markClosed());
-	}
-
-	send(js: string): void {
-		this.#write({ type: "eval", js });
-	}
-
-	close(): void {
-		this.#write({ type: "close" });
-	}
-
-	get closed(): boolean {
-		return this.#closed;
-	}
-
-	get failure(): Error | null {
-		return this.#failure;
-	}
-
-	#reportError(error: Error): void {
-		this.#failure ??= error;
-		this.emit("error", error);
-	}
-
-	#markClosed(): void {
-		if (this.#closed) return;
-		this.#closed = true;
-		this.emit("closed");
-	}
-
-	#write(obj: Record<string, unknown>): void {
-		if (this.#closed) return;
-		this.#proc.stdin.write(`${JSON.stringify(obj)}\n`);
-	}
-
-	setHTML(html: string): void {
-		this.#write({ type: "html", html: Buffer.from(html).toString("base64") });
-	}
+  #proc: ChildProcessWithoutNullStreams;
+  #closed = false;
+  #pendingHTML: string | null;
+  #stderr = "";
+  #failure: Error | null = null;
+
+  constructor(proc: ChildProcessWithoutNullStreams, initialHTML: string) {
+    super();
+    this.#proc = proc;
+    this.#pendingHTML = initialHTML;
+    // EventEmitter treats an unobserved `error` as fatal. Keep a permanent
+    // fallback while callers attach and detach their lifecycle listeners.
+    this.on("error", () => {});
+
+    proc.stdin.on("error", () => {});
+    proc.stderr.on("data", (chunk) => {
+      this.#stderr += chunk.toString();
+    });
+
+    const rl = createInterface({ input: proc.stdout, crlfDelay: Infinity });
+    rl.on("line", (line) => {
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        this.#reportError(new Error(`Malformed glimpse protocol line: ${line}`));
+        return;
+      }
+      if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return;
+      const message = parsed as GlimpseProtocolMessage;
+
+      switch (message.type) {
+        case "ready":
+          if (this.#pendingHTML != null) {
+            this.setHTML(this.#pendingHTML);
+            this.#pendingHTML = null;
+          }
+          break;
+        case "message":
+          this.emit("message", message.data);
+          break;
+        case "closed":
+          this.#markClosed();
+          break;
+        default:
+          break;
+      }
+    });
+
+    proc.on("error", (error) => this.#reportError(error));
+    proc.on("exit", (code, signal) => {
+      const stderr = this.#stderr.trim();
+      const failed = signal != null || (code != null && code !== 0);
+      if (!this.#closed && failed) {
+        const message =
+          stderr || `Glimpse process exited abnormally (code: ${code}, signal: ${signal}).`;
+        this.#reportError(new Error(message));
+      }
+      this.#markClosed();
+    });
+    // Spawn failures can emit `error` and then `close` without `exit`.
+    proc.on("close", () => this.#markClosed());
+  }
+
+  send(js: string): void {
+    this.#write({ type: "eval", js });
+  }
+
+  close(): void {
+    this.#write({ type: "close" });
+  }
+
+  get closed(): boolean {
+    return this.#closed;
+  }
+
+  get failure(): Error | null {
+    return this.#failure;
+  }
+
+  #reportError(error: Error): void {
+    this.#failure ??= error;
+    this.emit("error", error);
+  }
+
+  #markClosed(): void {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.emit("closed");
+  }
+
+  #write(obj: Record<string, unknown>): void {
+    if (this.#closed) return;
+    this.#proc.stdin.write(`${JSON.stringify(obj)}\n`);
+  }
+
+  setHTML(html: string): void {
+    this.#write({ type: "html", html: Buffer.from(html).toString("base64") });
+  }
 }
 
 async function getNativeHostInfo(): Promise<NativeHostInfo> {
-	const glimpseModule = (await import("glimpseui")) as unknown as { getNativeHostInfo: () => NativeHostInfo };
-	return glimpseModule.getNativeHostInfo();
+  const glimpseModule = (await import("glimpseui")) as unknown as {
+    getNativeHostInfo: () => NativeHostInfo;
+  };
+  return glimpseModule.getNativeHostInfo();
 }
 
-export async function openQuietGlimpse(html: string, options: GlimpseOpenOptions = {}): Promise<QuietGlimpseWindow> {
-	const host = await getNativeHostInfo();
-	if (!existsSync(host.path)) {
-		const hint = host.buildHint ? ` ${host.buildHint}` : "";
-		throw new Error(`Glimpse host not found at '${host.path}'.${hint}`);
-	}
-	const args: string[] = [];
-
-	if (options.width != null) args.push("--width", String(options.width));
-	if (options.height != null) args.push("--height", String(options.height));
-	if (options.title != null) args.push("--title", options.title);
-	if (options.frameless) args.push("--frameless");
-	if (options.floating) args.push("--floating");
-	if (options.transparent) args.push("--transparent");
-	if (options.clickThrough) args.push("--click-through");
-	if (options.hidden) args.push("--hidden");
-	if (options.autoClose) args.push("--auto-close");
-	if (options.x != null) args.push(`--x=${options.x}`);
-	if (options.y != null) args.push(`--y=${options.y}`);
-	if (options.cursorOffset?.x != null) args.push(`--cursor-offset-x=${options.cursorOffset.x}`);
-	if (options.cursorOffset?.y != null) args.push(`--cursor-offset-y=${options.cursorOffset.y}`);
-	if (options.cursorAnchor != null) args.push("--cursor-anchor", options.cursorAnchor);
-	if (options.followMode != null) args.push("--follow-mode", options.followMode);
-	if (options.followCursor) args.push("--follow-cursor");
-
-	const proc = spawn(host.path, [...(host.extraArgs ?? []), ...args], {
-		stdio: ["pipe", "pipe", "pipe"],
-		windowsHide: process.platform === "win32",
-		env: {
-			...process.env,
-			OS_ACTIVITY_MODE: process.env.OS_ACTIVITY_MODE ?? "disable",
-		},
-	});
-
-	return new QuietGlimpseWindowImpl(proc, html);
+export async function openQuietGlimpse(
+  html: string,
+  options: GlimpseOpenOptions = {},
+): Promise<QuietGlimpseWindow> {
+  const host = await getNativeHostInfo();
+  if (!existsSync(host.path)) {
+    const hint = host.buildHint ? ` ${host.buildHint}` : "";
+    throw new Error(`Glimpse host not found at '${host.path}'.${hint}`);
+  }
+  const args: string[] = [];
+
+  if (options.width != null) args.push("--width", String(options.width));
+  if (options.height != null) args.push("--height", String(options.height));
+  if (options.title != null) args.push("--title", options.title);
+  if (options.frameless) args.push("--frameless");
+  if (options.floating) args.push("--floating");
+  if (options.transparent) args.push("--transparent");
+  if (options.clickThrough) args.push("--click-through");
+  if (options.hidden) args.push("--hidden");
+  if (options.autoClose) args.push("--auto-close");
+  if (options.x != null) args.push(`--x=${options.x}`);
+  if (options.y != null) args.push(`--y=${options.y}`);
+  if (options.cursorOffset?.x != null) args.push(`--cursor-offset-x=${options.cursorOffset.x}`);
+  if (options.cursorOffset?.y != null) args.push(`--cursor-offset-y=${options.cursorOffset.y}`);
+  if (options.cursorAnchor != null) args.push("--cursor-anchor", options.cursorAnchor);
+  if (options.followMode != null) args.push("--follow-mode", options.followMode);
+  if (options.followCursor) args.push("--follow-cursor");
+
+  const proc = spawn(host.path, [...(host.extraArgs ?? []), ...args], {
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: process.platform === "win32",
+    env: {
+      ...process.env,
+      OS_ACTIVITY_MODE: process.env.OS_ACTIVITY_MODE ?? "disable",
+    },
+  });
+
+  return new QuietGlimpseWindowImpl(proc, html);
 }

package/extensions/annotate-last-message/session.ts

@@ -1,112 +1,117 @@
 import type { SessionEntry, SessionMessageEntry } from "@earendil-works/pi-coding-agent";
 
-import type { LastAssistantMessageData, LastAssistantMessageLookupResult, LastAssistantMessageSection } from "./types.js";
+import type {
+  LastAssistantMessageData,
+  LastAssistantMessageLookupResult,
+  LastAssistantMessageSection,
+} from "./types.js";
 
 const SECTION_PREVIEW_LIMIT = 96;
 
 function truncatePreview(value: string, limit = SECTION_PREVIEW_LIMIT): string {
-	const normalized = value.replace(/\s+/g, " ").trim();
-	if (normalized.length <= limit) return normalized;
-	return `${normalized.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= limit) return normalized;
+  return `${normalized.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
 }
 
 function assistantMessageText(
-	messageEntry: SessionMessageEntry,
+  messageEntry: SessionMessageEntry,
 ): { kind: "assistant"; text: string } | { kind: "incomplete"; stopReason: string } | null {
-	const { message } = messageEntry;
-	if (!("role" in message) || message.role !== "assistant") {
-		return null;
-	}
-	if (message.stopReason !== "stop") {
-		return { kind: "incomplete", stopReason: String(message.stopReason) };
-	}
-	if (!Array.isArray(message.content)) {
-		return { kind: "assistant", text: "" };
-	}
-	return {
-		kind: "assistant",
-		text: message.content
-			.filter((part): part is { type: "text"; text: string } => part.type === "text" && typeof part.text === "string")
-			.map((part) => part.text)
-			.join("\n")
-			.replace(/\r\n?/g, "\n"),
-	};
+  const { message } = messageEntry;
+  if (!("role" in message) || message.role !== "assistant") {
+    return null;
+  }
+  if (message.stopReason !== "stop") {
+    return { kind: "incomplete", stopReason: String(message.stopReason) };
+  }
+  if (!Array.isArray(message.content)) {
+    return { kind: "assistant", text: "" };
+  }
+  return {
+    kind: "assistant",
+    text: message.content
+      .filter(
+        (part): part is { type: "text"; text: string } =>
+          part.type === "text" && typeof part.text === "string",
+      )
+      .map((part) => part.text)
+      .join("\n")
+      .replace(/\r\n?/g, "\n"),
+  };
 }
 
 function buildSections(lines: string[]): LastAssistantMessageSection[] {
-	const sections: LastAssistantMessageSection[] = [];
-	let startIndex: number | null = null;
+  const sections: LastAssistantMessageSection[] = [];
+  let startIndex: number | null = null;
 
-	const flushSection = (endIndex: number): void => {
-		if (startIndex == null) return;
-		const sectionLines = lines.slice(startIndex, endIndex + 1);
-		const previewSource = sectionLines.find((line) => line.trim().length > 0) ?? "";
-		sections.push({
-			id: `section-${sections.length + 1}`,
-			index: sections.length + 1,
-			startLine: startIndex + 1,
-			endLine: endIndex + 1,
-			preview: truncatePreview(previewSource),
-			text: sectionLines.join("\n"),
-		});
-		startIndex = null;
-	};
+  const flushSection = (endIndex: number): void => {
+    if (startIndex == null) return;
+    const sectionLines = lines.slice(startIndex, endIndex + 1);
+    const previewSource = sectionLines.find((line) => line.trim().length > 0) ?? "";
+    sections.push({
+      id: `section-${sections.length + 1}`,
+      index: sections.length + 1,
+      startLine: startIndex + 1,
+      endLine: endIndex + 1,
+      preview: truncatePreview(previewSource),
+    });
+    startIndex = null;
+  };
 
-	for (let index = 0; index < lines.length; index += 1) {
-		const line = lines[index];
-		if (line.trim().length === 0) {
-			flushSection(index - 1);
-			continue;
-		}
-		if (startIndex == null) {
-			startIndex = index;
-		}
-	}
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line.trim().length === 0) {
+      flushSection(index - 1);
+      continue;
+    }
+    if (startIndex == null) {
+      startIndex = index;
+    }
+  }
 
-	flushSection(lines.length - 1);
-	return sections;
+  flushSection(lines.length - 1);
+  return sections;
 }
 
 export function findLastAssistantMessage(branch: SessionEntry[]): LastAssistantMessageLookupResult {
-	for (let index = branch.length - 1; index >= 0; index -= 1) {
-		const entry = branch[index];
-		if (entry.type !== "message") {
-			continue;
-		}
-		const extracted = assistantMessageText(entry);
-		if (extracted == null) {
-			continue;
-		}
-		if (extracted.kind === "incomplete") {
-			return {
-				ok: false,
-				code: "incomplete",
-				message: `Latest assistant message is incomplete (${extracted.stopReason}). Wait for it to finish, then try again.`,
-			};
-		}
+  for (let index = branch.length - 1; index >= 0; index -= 1) {
+    const entry = branch[index];
+    if (entry.type !== "message") {
+      continue;
+    }
+    const extracted = assistantMessageText(entry);
+    if (extracted == null) {
+      continue;
+    }
+    if (extracted.kind === "incomplete") {
+      return {
+        ok: false,
+        code: "incomplete",
+        message: `Latest assistant message is incomplete (${extracted.stopReason}). Wait for it to finish, then try again.`,
+      };
+    }
 
-		const text = extracted.text;
-		const trimmed = text.trim();
-		if (trimmed.length === 0) {
-			return {
-				ok: false,
-				code: "empty",
-				message: "Latest assistant message has no text to annotate.",
-			};
-		}
+    const text = extracted.text;
+    const trimmed = text.trim();
+    if (trimmed.length === 0) {
+      return {
+        ok: false,
+        code: "empty",
+        message: "Latest assistant message has no text to annotate.",
+      };
+    }
 
-		const lines = text.split("\n");
-		const data: LastAssistantMessageData = {
-			text,
-			lines: lines.map((line, lineIndex) => ({ number: lineIndex + 1, text: line })),
-			sections: buildSections(lines),
-		};
-		return { ok: true, data };
-	}
+    const lines = text.split("\n");
+    const data: LastAssistantMessageData = {
+      lines: lines.map((line, lineIndex) => ({ number: lineIndex + 1, text: line })),
+      sections: buildSections(lines),
+    };
+    return { ok: true, data };
+  }
 
-	return {
-		ok: false,
-		code: "missing",
-		message: "No assistant messages found on the current session branch.",
-	};
+  return {
+    ok: false,
+    code: "missing",
+    message: "No assistant messages found on the current session branch.",
+  };
 }