pi-edit-session-in-place 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mitch Fultz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,97 @@
+# pi edit-session-in-place
+
+A [pi](https://github.com/badlogic/pi-mono) extension that lets you rewind to an earlier user message in the current branch, then either **edit it in place** or **delete it and continue from there**.
+
+## What it does
+
+- Adds `/edit-turn`
+- Adds a global hotkey: `Ctrl+Shift+E`
+- Lets you choose an earlier user message from the current branch
+- Rewinds pi to that point in the same session file
+- Loads your edited text back into the main editor
+- Treats an empty submit as **delete this message and continue from here**
+
+## Install
+
+Install from npm with pi:
+
+```bash
+pi install npm:pi-edit-session-in-place
+```
+
+Or install directly from GitHub with pi:
+
+```bash
+pi install https://github.com/fitchmultz/pi-edit-session-in-place
+```
+
+Then reload pi from inside the app with:
+
+```text
+/reload
+```
+
+For local development you can point pi at the extension directly:
+
+```bash
+pi -e ./extensions/edit-session-in-place.ts
+```
+
+## Usage
+
+Inside pi:
+
+```text
+/edit-turn
+```
+
+Or press:
+
+```text
+Ctrl+Shift+E
+```
+
+### Message picker behavior
+
+- Shows earlier user messages from the current branch only
+- Uses a viewport so long threads stay navigable
+- Orders messages **oldest → newest**
+- Starts with the **newest** message selected at the bottom
+- `↑` moves to older messages, `↓` moves to newer ones
+- `PageUp` / `PageDown` jump faster
+
+### Editor behavior
+
+- `Ctrl+X` clears the entire selected message instantly
+- `Enter` submits the edited message
+- `Shift+Enter` inserts a newline
+- `Escape` cancels without changing history
+- `Ctrl+G` opens your external editor if `$VISUAL` or `$EDITOR` is set
+
+If you clear the message and submit an empty value, the selected message is effectively deleted: pi rewinds to just before that message and leaves the main editor empty so you can type a new prompt.
+
+## Behavior notes
+
+- Works in interactive mode; non-interactive modes do not show the picker/editor UI
+- Later messages on the abandoned branch are not deleted from the session file; they remain reachable through `/tree`
+- If the selected message contains images, the extension warns that re-editing or deleting it will drop the images and keep only text behavior
+- The extension only offers text-bearing user messages for editing; image-only or whitespace-only user messages are skipped
+- Queued messages must be cleared before using the command
+
+## Development
+
+This repo includes a small regression test in:
+
+- `tests/edit-session-in-place.test.ts`
+
+Checks:
+
+- message extraction from mixed session content
+- oldest-to-newest ordering for the picker
+- skipping image-only and whitespace-only user messages
+- preserving the image-warning flag for mixed text+image messages
+
+## Files
+
+- `extensions/edit-session-in-place.ts` — publishable extension implementation
+- `tests/edit-session-in-place.test.ts` — regression test for message extraction and ordering

package/extensions/edit-session-in-place.ts

@@ -0,0 +1,477 @@
+/**
+ * Purpose: Let the user rewind to and re-edit or delete an earlier user message in the current session branch.
+ * Responsibilities: Provide a selector UI, a fast clear-all edit UI, and tree navigation that rewinds to the selected point.
+ * Scope: Single publishable pi extension plus pure helpers exported for regression tests.
+ * Usage: Install as a pi package and invoke with /edit-turn or Ctrl+Shift+E.
+ * Invariants/Assumptions: Operates on the current branch only; later branch history remains in /tree; empty submit means delete.
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import {
+	CustomEditor,
+	DynamicBorder,
+	keyHint,
+	rawKeyHint,
+	type ExtensionAPI,
+	type ExtensionCommandContext,
+	type KeybindingsManager,
+	type SessionEntry,
+	type Theme,
+} from "@mariozechner/pi-coding-agent";
+import {
+	Container,
+	Editor,
+	SelectList,
+	Spacer,
+	Text,
+	matchesKey,
+	type EditorTheme,
+	type Focusable,
+	type TUI,
+} from "@mariozechner/pi-tui";
+
+const HOTKEY = "ctrl+shift+e";
+const CLEAR_ALL_KEY = "ctrl+x";
+const COMMAND_NAME = "edit-turn";
+const COMMAND_TEXT = `/${COMMAND_NAME}`;
+const SELECT_TITLE = "Pick a previous user message to edit";
+const EDIT_TITLE = "Edit previous user message";
+const PREVIEW_MAX_LENGTH = 90;
+const SELECTOR_MAX_VISIBLE = 12;
+const SELECTOR_PAGE_STEP = SELECTOR_MAX_VISIBLE - 1;
+
+type TextContentBlock = {
+	type?: string;
+	text?: string;
+};
+
+type ImageContentBlock = {
+	type?: string;
+};
+
+export type EditableUserMessage = {
+	entryId: string;
+	text: string;
+	hasImages: boolean;
+	label: string;
+};
+
+let draftBeforeHotkey: string | undefined;
+
+const clamp = (value: number, min: number, max: number) => Math.max(min, Math.min(value, max));
+const collapseWhitespace = (text: string) => text.replace(/\s+/g, " ").trim();
+
+const truncate = (text: string, maxLength: number) =>
+	text.length <= maxLength ? text : `${text.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+
+const formatTimestamp = (timestamp: string) => timestamp.slice(0, 16).replace("T", " ");
+
+const createEditorTheme = (theme: Theme): EditorTheme => ({
+	borderColor: (text) => theme.fg("accent", text),
+	selectList: {
+		selectedPrefix: (text) => theme.fg("accent", text),
+		selectedText: (text) => theme.fg("accent", text),
+		description: (text) => theme.fg("muted", text),
+		scrollInfo: (text) => theme.fg("dim", text),
+		noMatch: (text) => theme.fg("warning", text),
+	},
+});
+
+export const extractEditableText = (content: unknown): { text: string | undefined; hasImages: boolean } => {
+	if (typeof content === "string") {
+		const text = content.trim();
+		return { text: text.length > 0 ? content : undefined, hasImages: false };
+	}
+
+	if (!Array.isArray(content)) {
+		return { text: undefined, hasImages: false };
+	}
+
+	const textParts: string[] = [];
+	let hasImages = false;
+
+	for (const block of content) {
+		if (!block || typeof block !== "object") {
+			continue;
+		}
+
+		const textBlock = block as TextContentBlock;
+		if (textBlock.type === "text" && typeof textBlock.text === "string") {
+			textParts.push(textBlock.text);
+			continue;
+		}
+
+		const imageBlock = block as ImageContentBlock;
+		if (imageBlock.type === "image") {
+			hasImages = true;
+		}
+	}
+
+	const joined = textParts.join("\n");
+	return {
+		text: joined.trim().length > 0 ? joined : undefined,
+		hasImages,
+	};
+};
+
+export const getEditableMessages = (branch: SessionEntry[]): EditableUserMessage[] => {
+	const editable: EditableUserMessage[] = [];
+	const userEntries = branch.filter(
+		(entry): entry is SessionEntry & { type: "message"; message: { role: "user"; content: unknown } } =>
+			entry.type === "message" && entry.message.role === "user",
+	);
+
+	for (const entry of userEntries) {
+		const { text, hasImages } = extractEditableText(entry.message.content);
+		if (!text) {
+			continue;
+		}
+
+		const previewSource = collapseWhitespace(text.split("\n").find((line) => line.trim().length > 0) ?? text);
+		const preview = truncate(previewSource, PREVIEW_MAX_LENGTH);
+		const suffix = hasImages ? " [drops images]" : "";
+		const index = editable.length + 1;
+		editable.push({
+			entryId: entry.id,
+			text,
+			hasImages,
+			label: `${index}. ${formatTimestamp(entry.timestamp)} — ${preview}${suffix}`,
+		});
+	}
+
+	return editable;
+};
+
+class EditableMessageSelector extends Container {
+	private readonly tui: TUI;
+	private readonly keybindings: KeybindingsManager;
+	private readonly messages: EditableUserMessage[];
+	private readonly selectList: SelectList;
+	private readonly onSelect: (message: EditableUserMessage) => void;
+	private readonly onCancel: () => void;
+	private selectedIndex: number;
+
+	constructor(
+		tui: TUI,
+		theme: Theme,
+		keybindings: KeybindingsManager,
+		title: string,
+		messages: EditableUserMessage[],
+		onSelect: (message: EditableUserMessage) => void,
+		onCancel: () => void,
+	) {
+		super();
+		this.tui = tui;
+		this.keybindings = keybindings;
+		this.messages = messages;
+		this.onSelect = onSelect;
+		this.onCancel = onCancel;
+		this.selectedIndex = Math.max(0, messages.length - 1);
+
+		this.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(theme.fg("accent", title), 1, 0));
+		this.addChild(new Spacer(1));
+
+		this.selectList = new SelectList(
+			messages.map((message) => ({ value: message.entryId, label: message.label })),
+			SELECTOR_MAX_VISIBLE,
+			createEditorTheme(theme).selectList,
+			{ minPrimaryColumnWidth: 56, maxPrimaryColumnWidth: 120 },
+		);
+		this.selectList.setSelectedIndex(this.selectedIndex);
+		this.addChild(this.selectList);
+		this.addChild(new Spacer(1));
+		this.addChild(
+			new Text(
+				[
+					rawKeyHint("↑", "older"),
+					rawKeyHint("↓", "newer"),
+					keyHint("tui.select.pageUp", "jump up"),
+					keyHint("tui.select.pageDown", "jump down"),
+					keyHint("tui.select.confirm", "edit"),
+					keyHint("tui.select.cancel", "cancel"),
+				].join("  "),
+				1,
+				0,
+			),
+		);
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+	}
+
+	private setSelectedIndex(index: number) {
+		this.selectedIndex = clamp(index, 0, this.messages.length - 1);
+		this.selectList.setSelectedIndex(this.selectedIndex);
+		this.tui.requestRender();
+	}
+
+	handleInput(data: string): void {
+		if (this.keybindings.matches(data, "tui.select.up")) {
+			this.setSelectedIndex(this.selectedIndex - 1);
+			return;
+		}
+
+		if (this.keybindings.matches(data, "tui.select.down")) {
+			this.setSelectedIndex(this.selectedIndex + 1);
+			return;
+		}
+
+		if (this.keybindings.matches(data, "tui.select.pageUp")) {
+			this.setSelectedIndex(this.selectedIndex - SELECTOR_PAGE_STEP);
+			return;
+		}
+
+		if (this.keybindings.matches(data, "tui.select.pageDown")) {
+			this.setSelectedIndex(this.selectedIndex + SELECTOR_PAGE_STEP);
+			return;
+		}
+
+		if (this.keybindings.matches(data, "tui.select.confirm")) {
+			const selected = this.messages[this.selectedIndex];
+			if (selected) {
+				this.onSelect(selected);
+			}
+			return;
+		}
+
+		if (this.keybindings.matches(data, "tui.select.cancel")) {
+			this.onCancel();
+		}
+	}
+}
+
+class ReeditMessageEditor extends Container implements Focusable {
+	private readonly editor: Editor;
+	private readonly tui: TUI;
+	private readonly keybindings: KeybindingsManager;
+	private readonly onCancel: () => void;
+	private _focused = false;
+
+	get focused(): boolean {
+		return this._focused;
+	}
+
+	set focused(value: boolean) {
+		this._focused = value;
+		this.editor.focused = value;
+	}
+
+	constructor(
+		tui: TUI,
+		theme: Theme,
+		keybindings: KeybindingsManager,
+		title: string,
+		prefill: string,
+		onSubmit: (value: string) => void,
+		onCancel: () => void,
+	) {
+		super();
+		this.tui = tui;
+		this.keybindings = keybindings;
+		this.onCancel = onCancel;
+
+		this.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(theme.fg("accent", title), 1, 0));
+		this.addChild(new Spacer(1));
+
+		this.editor = new Editor(tui, createEditorTheme(theme));
+		this.editor.setText(prefill);
+		this.editor.onSubmit = (value) => onSubmit(value);
+		this.addChild(this.editor);
+		this.addChild(new Spacer(1));
+
+		const hasExternalEditor = Boolean(process.env.VISUAL || process.env.EDITOR);
+		const hint = [
+			keyHint("tui.select.confirm", "submit"),
+			keyHint("tui.input.newLine", "newline"),
+			rawKeyHint("ctrl+x", "clear all"),
+			rawKeyHint("empty+enter", "delete"),
+			keyHint("tui.select.cancel", "cancel"),
+			...(hasExternalEditor ? [keyHint("app.editor.external", "external editor")] : []),
+		].join("  ");
+		this.addChild(new Text(hint, 1, 0));
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, CLEAR_ALL_KEY)) {
+			this.editor.setText("");
+			this.tui.requestRender();
+			return;
+		}
+
+		if (this.keybindings.matches(data, "tui.select.cancel")) {
+			this.onCancel();
+			return;
+		}
+
+		if (this.keybindings.matches(data, "app.editor.external")) {
+			this.openExternalEditor();
+			return;
+		}
+
+		this.editor.handleInput(data);
+	}
+
+	private openExternalEditor() {
+		const editorCmd = process.env.VISUAL || process.env.EDITOR;
+		if (!editorCmd) {
+			return;
+		}
+
+		const currentText = this.editor.getText();
+		const tmpFile = path.join(os.tmpdir(), `pi-reedit-message-${Date.now()}.md`);
+
+		try {
+			fs.writeFileSync(tmpFile, currentText, "utf-8");
+			this.tui.stop();
+
+			const [editor, ...editorArgs] = editorCmd.split(" ");
+			const result = spawnSync(editor, [...editorArgs, tmpFile], {
+				stdio: "inherit",
+				shell: process.platform === "win32",
+			});
+
+			if (result.status === 0) {
+				const newContent = fs.readFileSync(tmpFile, "utf-8").replace(/\n$/, "");
+				this.editor.setText(newContent);
+			}
+		} finally {
+			try {
+				fs.unlinkSync(tmpFile);
+			} catch {
+				// Ignore cleanup errors.
+			}
+
+			this.tui.start();
+			this.tui.requestRender(true);
+		}
+	}
+}
+
+const selectEditableMessage = async (ctx: ExtensionCommandContext, messages: EditableUserMessage[]) =>
+	ctx.ui.custom<EditableUserMessage | undefined>((tui, theme, keybindings, done) =>
+		new EditableMessageSelector(tui, theme, keybindings, SELECT_TITLE, messages, (message) => done(message), () => done(undefined)),
+	);
+
+const editTextInCustomEditor = async (ctx: ExtensionCommandContext, prefill: string) =>
+	ctx.ui.custom<string | undefined>((tui, theme, keybindings, done) =>
+		new ReeditMessageEditor(tui, theme, keybindings, EDIT_TITLE, prefill, (value) => done(value), () => done(undefined)),
+	);
+
+const restoreDraftIfNeeded = (ctx: ExtensionCommandContext) => {
+	if (draftBeforeHotkey === undefined) {
+		return;
+	}
+
+	ctx.ui.setEditorText(draftBeforeHotkey);
+	draftBeforeHotkey = undefined;
+};
+
+const clearSavedDraft = () => {
+	draftBeforeHotkey = undefined;
+};
+
+const handleEditTurn = async (ctx: ExtensionCommandContext) => {
+	if (!ctx.hasUI) {
+		clearSavedDraft();
+		return;
+	}
+
+	if (ctx.hasPendingMessages()) {
+		ctx.ui.notify("Queued messages are pending. Press Escape first, then try again.", "warning");
+		restoreDraftIfNeeded(ctx);
+		return;
+	}
+
+	if (!ctx.isIdle()) {
+		ctx.abort();
+		await ctx.waitForIdle();
+	}
+
+	const editableMessages = getEditableMessages(ctx.sessionManager.getBranch());
+	if (editableMessages.length === 0) {
+		ctx.ui.notify("No editable text user messages found on the current branch.", "warning");
+		restoreDraftIfNeeded(ctx);
+		return;
+	}
+
+	const selected = await selectEditableMessage(ctx, editableMessages);
+	if (!selected) {
+		restoreDraftIfNeeded(ctx);
+		return;
+	}
+
+	if (selected.hasImages) {
+		const keepGoing = await ctx.ui.confirm(
+			"Drop images?",
+			"That message contains images. Editing or deleting it here will keep only the text and drop the images. Continue?",
+		);
+		if (!keepGoing) {
+			restoreDraftIfNeeded(ctx);
+			return;
+		}
+	}
+
+	const editedText = await editTextInCustomEditor(ctx, selected.text);
+	if (editedText === undefined) {
+		restoreDraftIfNeeded(ctx);
+		return;
+	}
+
+	const isDelete = editedText.trim().length === 0;
+	const result = await ctx.navigateTree(selected.entryId, { summarize: false });
+	if (result.cancelled) {
+		restoreDraftIfNeeded(ctx);
+		return;
+	}
+
+	clearSavedDraft();
+	ctx.ui.setEditorText(isDelete ? "" : editedText);
+	ctx.ui.notify(
+		isDelete
+			? "Message deleted. Type a new prompt to continue from that point."
+			: "Edited message loaded. Press Enter to continue from that point.",
+		"info",
+	);
+};
+
+class EditSessionInPlaceEditor extends CustomEditor {
+	handleInput(data: string): void {
+		if (matchesKey(data, HOTKEY)) {
+			draftBeforeHotkey = this.getText();
+			this.setText(COMMAND_TEXT);
+			super.handleInput("\r");
+			return;
+		}
+
+		super.handleInput(data);
+	}
+}
+
+export default function editSessionInPlace(pi: ExtensionAPI) {
+	pi.registerCommand(COMMAND_NAME, {
+		description: `Select and re-edit a previous user message on the current branch (${HOTKEY})`,
+		handler: async (_args, ctx) => {
+			await handleEditTurn(ctx);
+		},
+	});
+
+	pi.on("session_start", async () => {
+		clearSavedDraft();
+	});
+
+	pi.on("session_shutdown", async () => {
+		clearSavedDraft();
+	});
+
+	pi.on("session_start", (_event, ctx) => {
+		ctx.ui.setEditorComponent((tui, theme, keybindings) => new EditSessionInPlaceEditor(tui, theme, keybindings));
+	});
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "pi-edit-session-in-place",
+  "version": "0.1.0",
+  "description": "pi extension that lets you re-edit or delete an earlier user message in the current session branch",
+  "author": "Mitch Fultz (https://github.com/fitchmultz)",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "extension",
+    "session",
+    "history",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fitchmultz/pi-edit-session-in-place.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fitchmultz/pi-edit-session-in-place/issues"
+  },
+  "homepage": "https://github.com/fitchmultz/pi-edit-session-in-place#readme",
+  "scripts": {
+    "test": "node --experimental-strip-types tests/edit-session-in-place.test.ts",
+    "typecheck": "tsc --noEmit",
+    "check": "npm test && npm run typecheck",
+    "prepublishOnly": "npm run check && npm pack --dry-run"
+  },
+  "files": [
+    "extensions",
+    "README.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*"
+  },
+  "devDependencies": {
+    "@mariozechner/pi-coding-agent": "^0.65.2",
+    "@mariozechner/pi-tui": "^0.65.2",
+    "@types/node": "^24.6.0",
+    "typescript": "^5.9.3"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  }
+}