oira666_pi-watcher 0.0.2 → 0.0.4

package/README.md

@@ -2,7 +2,7 @@
 
 A persistent side-agent conversation for your running [Pi](https://pi.dev) agent.
 
-**Package:** `oira666_pi-watcher` · **Version:** `0.0.2` · **License:** MIT
+**Package:** `oira666_pi-watcher` · **Version:** `0.0.4` · **License:** MIT
 
 ## Install
 
@@ -23,20 +23,29 @@ pi -e ./src/index.ts
 
 | Command | Action |
 | --- | --- |
+| **Ctrl+W** | Toggle the Watcher panel without sending a prompt or stopping either agent. |
 | `/watcher` | Create/resume the side agent and show its conversation. **Sends no prompt.** |
 | `/watcher Why is it retrying?` | Open and send exactly that question. |
 | `/watcher model` | Open the side agent's model picker. Does not prompt either agent. |
 
-These are human-facing TUI commands, not tools exposed to the main agent. They work while the main agent is running, including during compaction.
+Ctrl+W replaces Pi's usual delete-word-left shortcut while Watcher is loaded.
+
+These are human-facing TUI controls, not tools exposed to the main agent. They work while the main agent is running, including during compaction.
 
 The panel opens immediately while the side process initializes its inherited extensions and MCPs in the background. You can type straight away; a submitted question waits for initialization and is sent once ready. `/stop` cancels a question waiting for startup. Opening without a question still sends no prompt. Saved history and the selected model appear when initialization finishes; reopening an already initialized side agent reuses it.
 
 Inside the overlay:
 
 - Type a question and press **Enter**. Use **Shift+Enter** for a newline.
-- **Esc** returns to the main view without stopping either agent. Run `/watcher` again to return; conversation, draft, and scroll position are retained.
+- **Ctrl+W** closes the panel from any Watcher view. Press it again to reopen. **Esc** also returns from chat to the main view without stopping either agent. Conversation, draft, and scroll position are retained.
 - `/model` opens a searchable provider/model picker. Its selection affects **only the side agent** and is persisted in that side conversation. You can change models while the side agent is running, just like in Pi; switching does not abort the current reply.
 - `/stop` cancels only the side agent and clears its queued messages.
+- `/copy` copies to the system clipboard, because terminal mouse selection spans the full terminal width. Messages are numbered in the transcript (`You #n`, `Watcher #n`):
+  - `/copy`: last Watcher reply · `/copy 3`: Watcher #3
+  - `/copy me`: your last message · `/copy me 2`: You #2
+  - `/copy all`: the whole side conversation as Markdown
+
+  It uses Pi's clipboard support (native clipboard, `wl-copy`/`xclip`/`xsel`, or OSC 52 over SSH). Copying never sends a prompt.
 - `/help` shows controls. **Page Up/Down**, **Ctrl+Home/End**, or the mouse wheel scroll the conversation.
 - Watcher never modifies the main status bar. Reopen the overlay to see pending approvals; finished replies can trigger a notification.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-watcher",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "A persistent side-agent conversation for observing and steering your running Pi agent.",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -269,6 +269,20 @@ export default function watcher(pi: ExtensionAPI): void {
   pi.on("session_compact", () => { compacting = false; mainStatus(); });
   pi.on("session_compact_failed", () => { compacting = false; mainStatus(); });
 
+  pi.registerShortcut("ctrl+w", {
+    description: "Toggle the Watcher panel",
+    handler: async (ctx) => {
+      if (ctx.mode !== "tui" || !ctx.hasUI) return;
+      try {
+        if (side && isCurrent(side) && side.store.state.open) {
+          side.overlay?.abort();
+          return;
+        }
+        await show(await ensure(ctx));
+      } catch (error) { ctx.ui.notify(`Watcher: ${errorText(error)}`, "error"); }
+    },
+  });
+
   pi.registerCommand("watcher", {
     description: "Open the side agent; /watcher <question> to ask; /watcher model to choose its model",
     handler: async (args, ctx) => {

package/src/ui-copy.ts

@@ -0,0 +1,61 @@
+/**
+ * `/copy` support for the watcher overlay. Terminal selection cannot be limited to the overlay
+ * column, so messages are copied to the system clipboard instead. Pure parsing/selection here;
+ * the clipboard write itself is injected (Pi's copyToClipboard by default).
+ */
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+import { messageNumbers } from "./ui-render.ts";
+import type { WatcherLiveState, WatcherMessage } from "./ui-types.ts";
+
+export const COPY_USAGE = "/copy [me] [n|all] — e.g. /copy (last Watcher reply), /copy 3 (Watcher #3), /copy me (your last), /copy me 2, /copy all";
+
+export type CopySelection = { ok: true; text: string; label: string } | { ok: false; error: string };
+
+const ME = new Set(["me", "my", "mine", "you", "user"]);
+const AGENT = new Set(["agent", "watcher", "assistant", "reply", "w"]);
+
+function clean(text: string): string {
+	return stripTerminalSequences(text).replace(/\r\n?/g, "\n");
+}
+
+/** Resolve `/copy` arguments against the stored conversation. */
+export function selectForCopy(messages: ReadonlyArray<WatcherMessage>, args: string, live?: WatcherLiveState): CopySelection {
+	// Copy a snapshot of the visible reply without committing it to history.
+	if (live?.text) {
+		const prefix = live.truncated ? "… (earlier output not retained)\n" : "";
+		messages = [...messages, { role: "assistant", text: prefix + live.text }];
+	}
+	const words = args.trim().toLowerCase().split(/\s+/).filter(Boolean);
+	let role: "user" | "assistant" = "assistant";
+	let which: "last" | "all" | number = "last";
+	for (const w of words) {
+		const n = /^#?(\d+)$/.exec(w);
+		if (ME.has(w)) role = "user";
+		else if (AGENT.has(w)) role = "assistant";
+		else if (w === "all") which = "all";
+		else if (w === "last") which = "last";
+		else if (n) which = Number(n[1]);
+		else return { ok: false, error: `Unknown /copy argument "${w}". Usage: ${COPY_USAGE}` };
+	}
+
+	if (which === "all") {
+		const numbers = messageNumbers(messages);
+		const parts: string[] = [];
+		messages.forEach((m, i) => {
+			const text = clean(m.text).trim();
+			if (m.role === "user") parts.push(`## You #${numbers[i]}\n\n${text}`);
+			else if (m.role === "assistant") parts.push(`## Watcher #${numbers[i]}\n\n${text}`);
+			else parts.push(`> ⚙ ${text.split("\n").join("\n> ")}`);
+		});
+		if (!parts.length) return { ok: false, error: "Nothing to copy: the side conversation is empty." };
+		return { ok: true, text: `${parts.join("\n\n")}\n`, label: "whole conversation" };
+	}
+
+	const own = messages.filter((m) => m.role === role);
+	const name = role === "user" ? "You" : "Watcher";
+	if (!own.length) return { ok: false, error: role === "user" ? "You have not sent any messages yet." : "No Watcher reply yet." };
+	const index = which === "last" ? own.length : which;
+	const msg = own[index - 1];
+	if (!msg) return { ok: false, error: `No ${name} #${index}. Available: #1–#${own.length}.` };
+	return { ok: true, text: clean(msg.text), label: `${name} #${index}` };
+}

package/src/ui-render.ts

@@ -28,9 +28,20 @@ function fit(lines: string[], width: number): string[] {
 
 interface MsgCacheEntry {
 	width: number;
+	number: number;
 	lines: string[];
 }
 
+/**
+ * 1-based per-role number of each message (user and assistant counted separately; tool entries get 0).
+ * Shown as "You #n" / "Watcher #n" and used by `/copy`.
+ */
+export function messageNumbers(messages: ReadonlyArray<WatcherMessage>): number[] {
+	let user = 0;
+	let assistant = 0;
+	return messages.map((m) => (m.role === "user" ? ++user : m.role === "assistant" ? ++assistant : 0));
+}
+
 export class TranscriptRenderer {
 	private getTheme: () => Theme;
 	private msgCache = new WeakMap<WatcherMessage, MsgCacheEntry>();
@@ -67,11 +78,13 @@ export class TranscriptRenderer {
 		const theme = this.getTheme();
 		const lines: string[] = [];
 		if (start > 0) lines.push(theme.fg("dim", truncateToWidth(`… ${start} earlier message${start === 1 ? "" : "s"} not shown`, width, "…")), "");
+		const numbers = messageNumbers(messages);
 		for (let i = start; i < total; i++) {
 			const m = messages[i]!;
+			const number = numbers[i]!;
 			let entry = this.msgCache.get(m);
-			if (!entry || entry.width !== width) {
-				entry = { width, lines: this.renderMessage(m, width) };
+			if (!entry || entry.width !== width || entry.number !== number) {
+				entry = { width, number, lines: this.renderMessage(m, width, number) };
 				this.msgCache.set(m, entry);
 			}
 			for (const l of entry.lines) lines.push(l);
@@ -80,16 +93,16 @@ export class TranscriptRenderer {
 		return lines;
 	}
 
-	private renderMessage(m: WatcherMessage, width: number): string[] {
+	private renderMessage(m: WatcherMessage, width: number, number: number): string[] {
 		const theme = this.getTheme();
 		const { text, cut } = sanitizeText(m.text, WATCHER_LIMITS.maxRenderedMessageChars);
 		const note = cut ? [theme.fg("dim", "  … (message truncated)")] : [];
 		const out: string[] = [];
 		if (m.role === "user") {
-			out.push(theme.fg("accent", theme.bold("You")));
+			out.push(theme.fg("accent", theme.bold("You")) + theme.fg("dim", ` #${number}`));
 			for (const l of wrapTextWithAnsi(text, Math.max(1, width - 2))) out.push(`  ${l}`);
 		} else if (m.role === "assistant") {
-			out.push(theme.fg("success", theme.bold("Watcher")));
+			out.push(theme.fg("success", theme.bold("Watcher")) + theme.fg("dim", ` #${number}`));
 			const md = new Markdown(text, 1, 0, getMarkdownTheme());
 			for (const l of md.render(width)) out.push(l);
 		} else {

package/src/ui.ts

@@ -5,7 +5,7 @@
  * this module renders the store, collects input, and calls WatcherController callbacks.
  * It never aborts the main agent and never performs steering itself.
  */
-import type { Theme } from "@earendil-works/pi-coding-agent";
+import { copyToClipboard, type Theme } from "@earendil-works/pi-coding-agent";
 import {
 	type Component,
 	Editor,
@@ -24,6 +24,7 @@ import {
 	wrapTextWithAnsi,
 	decodeKittyPrintable,
 } from "@earendil-works/pi-tui";
+import { COPY_USAGE, selectForCopy } from "./ui-copy.ts";
 import { TranscriptRenderer, sanitizeText } from "./ui-render.ts";
 import { WatcherStore } from "./ui-store.ts";
 import {
@@ -37,7 +38,8 @@ import {
 
 export * from "./ui-types.ts";
 export { WatcherStore, normalizeMessage, type EndTurnOptions, type WatcherStoreInit } from "./ui-store.ts";
-export { TranscriptRenderer, sanitizeText } from "./ui-render.ts";
+export { TranscriptRenderer, sanitizeText, messageNumbers } from "./ui-render.ts";
+export { selectForCopy, COPY_USAGE, type CopySelection } from "./ui-copy.ts";
 
 export interface OpenWatcherUIOptions {
 	store: WatcherStore;
@@ -48,6 +50,8 @@ export interface OpenWatcherUIOptions {
 	signal?: AbortSignal;
 	/** "model": open the side-model picker immediately (e.g. `/watcher model`). Never sends a prompt. */
 	initialAction?: "model";
+	/** Clipboard writer used by `/copy`. Default: Pi's copyToClipboard. */
+	copyText?: (text: string) => Promise<void>;
 }
 
 type Mode = "chat" | "model" | "approval-edit";
@@ -102,12 +106,14 @@ export class WatcherOverlay implements Component, Focusable {
 	private title: string;
 	private done: (r: WatcherUIResult) => void;
 	private renderer: TranscriptRenderer;
+	private copyText: (text: string) => Promise<void>;
 
 	private _focused = false;
 	private closed = false;
 	private mode: Mode = "chat";
 	private editor: Editor;
 	private approvalEditor?: Editor;
+	private commandEditor?: Editor;
 	private approvalId?: string;
 	private approvalSel = 1; // 0 send, 1 edit (default, no accidental send), 2 cancel
 
@@ -144,6 +150,7 @@ export class WatcherOverlay implements Component, Focusable {
 		this.title = options.title ?? "Watcher";
 		this.done = done;
 		this.renderer = new TranscriptRenderer(() => this.theme);
+		this.copyText = options.copyText ?? copyToClipboard;
 
 		this.editor = new Editor(tui, this.editorTheme(), { paddingX: 0 });
 		if (this.store.state.draft) this.editor.setText(this.store.state.draft);
@@ -175,9 +182,10 @@ export class WatcherOverlay implements Component, Focusable {
 	}
 
 	private syncEditorFocus(): void {
-		const chat = this.mode === "chat" && !this.currentApproval();
+		const chat = !this.commandEditor && this.mode === "chat" && !this.currentApproval();
 		this.editor.focused = this._focused && chat;
-		if (this.approvalEditor) this.approvalEditor.focused = this._focused && this.mode === "approval-edit";
+		if (this.approvalEditor) this.approvalEditor.focused = this._focused && !this.commandEditor && this.mode === "approval-edit";
+		if (this.commandEditor) this.commandEditor.focused = this._focused;
 	}
 
 	// ---- lifecycle -------------------------------------------------------------------------
@@ -189,6 +197,7 @@ export class WatcherOverlay implements Component, Focusable {
 		this.renderer.invalidate();
 		this.editor.invalidate();
 		this.approvalEditor?.invalidate();
+		this.commandEditor?.invalidate();
 		this.pickerList?.invalidate();
 	}
 
@@ -304,11 +313,19 @@ export class WatcherOverlay implements Component, Focusable {
 
 	handleInput(data: string): void {
 		if (this.closed) return;
+		// Focused overlays own input, so the main editor's shortcut cannot close us.
+		if (matchesKey(data, "ctrl+w")) {
+			this.close("closed");
+			return;
+		}
 		if (this.notice) {
 			this.notice = undefined;
 			this.requestRender();
 		}
-		if (this.mode === "model") {
+		if (this.commandEditor) {
+			if (this.isClose(data)) this.commandEditor = undefined;
+			else this.commandEditor.handleInput(data);
+		} else if (this.mode === "model") {
 			this.handlePickerInput(data);
 		} else if (this.mode === "approval-edit") {
 			this.handleApprovalEditInput(data);
@@ -340,12 +357,10 @@ export class WatcherOverlay implements Component, Focusable {
 	private onEditorSubmit(raw: string): void {
 		const text = raw.trim();
 		if (!text) return;
-		const cmd = /^\/(model|stop|help)(?:\s+([\s\S]*))?$/.exec(text);
+		const cmd = /^\/(model|stop|help|copy)(?:\s+([\s\S]*))?$/.exec(text);
 		if (cmd) {
 			this.clearEditor();
-			if (cmd[1] === "model") this.openPicker((cmd[2] ?? "").trim());
-			else if (cmd[1] === "stop") this.doStop();
-			else this.setNotice("Enter send · Shift+Enter newline · PgUp/PgDn scroll · /model [filter] · /stop · Esc close (main agent untouched)");
+			this.runLocalCommand(cmd[1], cmd[2] ?? "");
 			return;
 		}
 		if (this.sideBusy()) {
@@ -378,6 +393,44 @@ export class WatcherOverlay implements Component, Focusable {
 		this.store.setDraft("");
 	}
 
+	private runLocalCommand(command: string, args: string): void {
+		if (command === "model") this.openPicker(args.trim());
+		else if (command === "stop") this.doStop();
+		else if (command === "copy") this.doCopy(args);
+		else this.setNotice(`Enter send · Shift+Enter newline · PgUp/PgDn scroll · /model [filter] · /stop · ${COPY_USAGE} · Ctrl+W / Esc close (main agent untouched)`);
+	}
+
+	/** Allow local commands while an approval owns the normal input controls. */
+	private openCommandEditor(): void {
+		const editor = new Editor(this.tui, this.editorTheme(), { paddingX: 0 });
+		editor.setText("/");
+		editor.onSubmit = (raw) => {
+			const cmd = /^\/(model|stop|help|copy)(?:\s+([\s\S]*))?$/.exec(raw.trim());
+			if (cmd) {
+				this.commandEditor = undefined;
+				this.runLocalCommand(cmd[1], cmd[2] ?? "");
+			} else editor.setText(raw);
+		};
+		this.commandEditor = editor;
+	}
+
+	private doCopy(args: string): void {
+		const sel = selectForCopy(this.store.state.messages, args, this.store.state.live);
+		if (!sel.ok) {
+			this.setNotice(sel.error, "warn");
+			return;
+		}
+		this.guarded(
+			async () => {
+				await this.copyText(sel.text);
+				if (!this.closed) this.setNotice(`Copied ${sel.label} (${sel.text.length.toLocaleString("en-US")} chars)`);
+			},
+			(err) => {
+				if (!this.closed) this.setNotice(`Copy failed: ${errMsg(err)}`, "error");
+			},
+		);
+	}
+
 	private doStop(): void {
 		const status = this.store.state.side.status;
 		if (status !== "running") {
@@ -525,6 +578,10 @@ export class WatcherOverlay implements Component, Focusable {
 	}
 
 	private handleApprovalInput(data: string): void {
+		if (data === "/" || decodeKittyPrintable(data) === "/") {
+			this.openCommandEditor();
+			return;
+		}
 		const a = this.currentApproval();
 		if (!a) return;
 		if (this.isClose(data)) {
@@ -685,9 +742,10 @@ export class WatcherOverlay implements Component, Focusable {
 		if (this.mode === "model") txt = "type filter · ↑↓ · Enter select · Esc back";
 		else if (this.mode === "approval-edit") txt = "Enter send edited · Shift+Enter newline · Esc back";
 		else if (this.currentApproval()) txt = "←/→ select · Enter confirm · Esc close (stays pending)";
-		else if (inner >= 70) txt = "Enter send · ⇧Enter newline · PgUp/PgDn scroll · /model · /stop · Esc close";
-		else if (inner >= 44) txt = "Enter send · PgUp/PgDn · /model · /stop · Esc";
+		else if (inner >= 76) txt = "Enter send · ⇧Enter newline · PgUp/PgDn scroll · /model · /copy · /stop · Esc close";
+		else if (inner >= 50) txt = "Enter send · PgUp/PgDn · /model · /copy · /stop · Esc";
 		else txt = "Enter send · Esc close";
+		txt = `Ctrl+W close · ${txt}`;
 		return th.fg("dim", ` ${txt}`);
 	}
 
@@ -698,14 +756,16 @@ export class WatcherOverlay implements Component, Focusable {
 		if (this.notice) {
 			const color = this.notice.level === "error" ? "error" : this.notice.level === "warn" ? "warning" : "accent";
 			const { text } = sanitizeText(this.notice.text, 600);
-			const wrapped = wrapTextWithAnsi(text, Math.max(1, inner - 3)).slice(0, 3);
+			const wrapped = wrapTextWithAnsi(text, Math.max(1, inner - 3)).slice(0, 5);
 			wrapped.forEach((l, i) => lines.push(frame(` ${th.fg(color, i === 0 ? "! " : "  ")}${th.fg(color, l)}`)));
 		}
 
 		const approval = this.currentApproval();
 		const editorCap = Math.max(3, Math.min(8, Math.floor(H * 0.35)));
 
-		if (this.mode === "model") {
+		if (this.commandEditor) {
+			for (const l of this.capEditorLines(this.commandEditor.render(inner), editorCap)) lines.push(frame(l));
+		} else if (this.mode === "model") {
 			lines.push(frame(` ${th.fg("accent", th.bold("Select side model"))} ${th.fg("dim", "(independent of main)")}`));
 			lines.push(frame(` ${th.fg("muted", "filter:")} ${this.pickerFilter}${th.fg("dim", "▏")}`));
 			if (this.pickerLoading) lines.push(frame(th.fg("dim", "  loading models…")));