pi-anycopy 0.2.1 → 0.2.3

package/README.md

@@ -47,7 +47,7 @@ Defaults (customizable in `config.json`):
 | Key | Action |
 |-----|--------|
 | `Enter` | Navigate to the focused node (same semantics as `/tree`) |
-| `Space` | Select/unselect focused node for copy |
+| `Shift+A` | Select/unselect focused node for copy |
 | `Shift+C` | Copy selected nodes, or the focused node if nothing is selected |
 | `Shift+X` | Clear selection |
 | `Shift+L` | Label node (native tree behavior) |
@@ -65,11 +65,13 @@ Notes:
 - If no nodes are selected, `Shift+C` copies the focused node
 - Single-node copies use just that node's content; role prefixes like `user:` or `assistant:` are only added when copying 2 or more nodes
 - When copying multiple selected nodes, they are auto-sorted chronologically by position in the session tree, not by selection order
-- Space/`Shift+C` multi-select copy behavior is unchanged by navigation support
+- `Shift+A`/`Shift+C` multi-select copy behavior is unchanged by navigation support, while plain space remains available for search queries
 - `Shift+T` is configurable via `keys.toggleLabelTimestamps` in `config.json`
 - `Shift+T` shows timestamps for labeled nodes only, using the latest label-change time for each label
 - Same-day labels show `HH:MM`; older labels show `M/D HH:MM`; cross-year labels show `YY/M/D HH:MM`
 - Label edits are persisted via `pi.setLabel(...)`
+- [Folded](https://github.com/badlogic/pi-mono/blob/09e9de5749193beab234f30ed220a77f3d91cfad/packages/coding-agent/docs/tree.md#controls) branches are persisted by default in hidden `/anycopy` session entries, so closing/reopening `/anycopy`, switching to a sibling branch, or revisiting the session later restores the same folded view until you explicitly unfold it again
+- Search and filter changes still reset the live overlay's fold state temporarily; reopening `/anycopy` restores the persisted folded branches
 
 ## Configuration
 
@@ -77,13 +79,15 @@ Edit `~/.pi/agent/extensions/anycopy/config.json`:
 
 - `treeFilterMode`: initial tree filter mode when opening `/anycopy`; defaults to `default` to match `/tree`
   - one of: `default` | `no-tools` | `user-only` | `labeled-only` | `all`
+- `persistFoldState`: whether `/anycopy` persists folded branches across reopenings and later sessions; defaults to `true`; when disabled, `/anycopy` does not read or write hidden fold-state session entries
 - `keys`: keybindings used inside the `/anycopy` overlay for copy/preview actions, including the label timestamp toggle
 
 ```json
 {
   "treeFilterMode": "default",
+  "persistFoldState": true,
   "keys": {
-    "toggleSelect": "space",
+    "toggleSelect": "shift+a",
     "copy": "shift+c",
     "clear": "shift+x",
     "toggleLabelTimestamps": "shift+t",

package/extensions/anycopy/config.json

@@ -1,7 +1,8 @@
 {
   "treeFilterMode": "no-tools",
+  "persistFoldState": true,
   "keys": {
-    "toggleSelect": "space",
+    "toggleSelect": "shift+a",
     "copy": "shift+c",
     "clear": "shift+x",
     "toggleLabelTimestamps": "shift+t",

package/extensions/anycopy/fold-state.ts

@@ -0,0 +1,146 @@
+import type { SessionEntry } from "@mariozechner/pi-coding-agent";
+
+export const ANYCOPY_FOLD_STATE_CUSTOM_TYPE = "anycopy-fold-state";
+const FOLD_STATE_SCHEMA_VERSION = 1;
+
+type TreeSelectorLike = {
+	getTreeList(): unknown;
+};
+
+type TreeListInternals = {
+	foldedNodes?: Set<string>;
+	flatNodes?: Array<{ node?: { entry?: { id?: string } } }>;
+	applyFilter?: () => void;
+	isFoldable?: (entryId: string) => boolean;
+};
+
+export type AnycopyFoldStateEntryData = {
+	v: 1;
+	foldedNodeIds: string[];
+};
+
+type MergeExplicitFoldMutationArgs = {
+	durableFoldedNodeIds: Iterable<string>;
+	beforeTransientFoldedNodeIds: Iterable<string>;
+	afterTransientFoldedNodeIds: Iterable<string>;
+	validNodeIds?: ReadonlySet<string>;
+};
+
+export const normalizeFoldedNodeIds = (
+	nodeIds: Iterable<unknown>,
+	validNodeIds?: ReadonlySet<string>,
+): string[] => {
+	const uniqueNodeIds = new Set<string>();
+	for (const nodeId of nodeIds) {
+		if (typeof nodeId !== "string" || nodeId.length === 0) continue;
+		if (validNodeIds && !validNodeIds.has(nodeId)) continue;
+		uniqueNodeIds.add(nodeId);
+	}
+	return [...uniqueNodeIds].sort();
+};
+
+export const foldStateNodeIdListsEqual = (left: readonly string[], right: readonly string[]): boolean =>
+	left.length === right.length && left.every((value, index) => value === right[index]);
+
+export const createFoldStateEntryData = (
+	foldedNodeIds: Iterable<string>,
+	validNodeIds?: ReadonlySet<string>,
+): AnycopyFoldStateEntryData => ({
+	v: FOLD_STATE_SCHEMA_VERSION,
+	foldedNodeIds: normalizeFoldedNodeIds(foldedNodeIds, validNodeIds),
+});
+
+export const parseFoldStateEntryData = (
+	data: unknown,
+	validNodeIds?: ReadonlySet<string>,
+): AnycopyFoldStateEntryData | null => {
+	if (!data || typeof data !== "object") return null;
+
+	const candidate = data as { v?: unknown; foldedNodeIds?: unknown };
+	if (candidate.v !== FOLD_STATE_SCHEMA_VERSION || !Array.isArray(candidate.foldedNodeIds)) {
+		return null;
+	}
+
+	return createFoldStateEntryData(candidate.foldedNodeIds, validNodeIds);
+};
+
+const getTreeListInternals = (selector: TreeSelectorLike): TreeListInternals | null => {
+	const treeList = selector.getTreeList();
+	if (!treeList || typeof treeList !== "object") return null;
+	return treeList as TreeListInternals;
+};
+
+export const getSelectorFoldedNodeIds = (selector: TreeSelectorLike): string[] => {
+	const internals = getTreeListInternals(selector);
+	if (!internals?.foldedNodes) return [];
+	return normalizeFoldedNodeIds(internals.foldedNodes);
+};
+
+export const setSelectorFoldedNodeIds = (selector: TreeSelectorLike, entryIds: Iterable<string>): string[] => {
+	const internals = getTreeListInternals(selector);
+	if (!internals?.foldedNodes || !internals.applyFilter || !Array.isArray(internals.flatNodes)) {
+		return [];
+	}
+
+	const validNodeIds = new Set(
+		internals.flatNodes
+			.map((flatNode) => flatNode.node?.entry?.id)
+			.filter((entryId): entryId is string => typeof entryId === "string"),
+	);
+
+	internals.foldedNodes.clear();
+	internals.applyFilter();
+
+	for (const entryId of normalizeFoldedNodeIds(entryIds, validNodeIds)) {
+		if (!internals.isFoldable || internals.isFoldable(entryId)) {
+			internals.foldedNodes.add(entryId);
+		}
+	}
+
+	internals.applyFilter();
+	return normalizeFoldedNodeIds(internals.foldedNodes);
+};
+
+export const loadLatestFoldStateFromEntries = (
+	entries: Iterable<SessionEntry>,
+	validNodeIds?: ReadonlySet<string>,
+): AnycopyFoldStateEntryData | null => {
+	const sessionEntries = [...entries];
+	for (let index = sessionEntries.length - 1; index >= 0; index -= 1) {
+		const entry = sessionEntries[index];
+		if (entry.type !== "custom" || entry.customType !== ANYCOPY_FOLD_STATE_CUSTOM_TYPE) {
+			continue;
+		}
+
+		const parsedEntry = parseFoldStateEntryData(entry.data, validNodeIds);
+		if (parsedEntry) {
+			return parsedEntry;
+		}
+	}
+
+	return null;
+};
+
+export const mergeExplicitFoldMutation = ({
+	durableFoldedNodeIds,
+	beforeTransientFoldedNodeIds,
+	afterTransientFoldedNodeIds,
+	validNodeIds,
+}: MergeExplicitFoldMutationArgs): string[] => {
+	const normalizedDurableFoldedNodeIds = normalizeFoldedNodeIds(durableFoldedNodeIds, validNodeIds);
+	const normalizedBeforeTransientFoldedNodeIds = normalizeFoldedNodeIds(beforeTransientFoldedNodeIds, validNodeIds);
+	const normalizedAfterTransientFoldedNodeIds = normalizeFoldedNodeIds(afterTransientFoldedNodeIds, validNodeIds);
+
+	const removedNodeIds = new Set(
+		normalizedBeforeTransientFoldedNodeIds.filter((nodeId) => !normalizedAfterTransientFoldedNodeIds.includes(nodeId)),
+	);
+	const addedNodeIds = new Set(
+		normalizedAfterTransientFoldedNodeIds.filter((nodeId) => !normalizedBeforeTransientFoldedNodeIds.includes(nodeId)),
+	);
+	const nextDurableFoldedNodeIds = normalizedDurableFoldedNodeIds.filter((nodeId) => !removedNodeIds.has(nodeId));
+	for (const nodeId of addedNodeIds) {
+		nextDurableFoldedNodeIds.push(nodeId);
+	}
+
+	return normalizeFoldedNodeIds(nextDurableFoldedNodeIds, validNodeIds);
+};

package/extensions/anycopy/index.ts

@@ -4,7 +4,7 @@
  * Layout: native TreeSelectorComponent at top, status bar, preview below
  *
  * Default keys (customizable via ./config.json):
- *   Space     - select/unselect focused node for copy
+ *   Shift+A   - select/unselect focused node for copy
  *   Shift+C   - copy selected nodes (or focused node if none selected)
  *   Shift+X   - clear selection
  *   Shift+L   - label node
@@ -23,7 +23,7 @@ import {
 	TreeSelectorComponent,
 } from "@mariozechner/pi-coding-agent";
 
-import { Markdown, matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
+import { getKeybindings, Markdown, matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
 import type { Focusable } from "@mariozechner/pi-tui";
 
 import { existsSync, readFileSync } from "fs";
@@ -32,6 +32,16 @@ import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 
 import { runAnycopyEnterNavigation } from "./enter-navigation.ts";
+import {
+	ANYCOPY_FOLD_STATE_CUSTOM_TYPE,
+	createFoldStateEntryData,
+	foldStateNodeIdListsEqual,
+	getSelectorFoldedNodeIds,
+	loadLatestFoldStateFromEntries,
+	mergeExplicitFoldMutation,
+	normalizeFoldedNodeIds,
+	setSelectorFoldedNodeIds,
+} from "./fold-state.ts";
 
 type SessionTreeNode = {
 	entry: SessionEntry;
@@ -56,11 +66,13 @@ type TreeFilterMode = "default" | "no-tools" | "user-only" | "labeled-only" | "a
 type anycopyConfig = {
 	keys?: Partial<anycopyKeyConfig>;
 	treeFilterMode?: TreeFilterMode;
+	persistFoldState?: boolean;
 };
 
 type anycopyRuntimeConfig = {
 	keys: anycopyKeyConfig;
 	treeFilterMode: TreeFilterMode;
+	persistFoldState: boolean;
 };
 
 type BranchSummarySettingsFile = {
@@ -70,7 +82,7 @@ type BranchSummarySettingsFile = {
 };
 
 const DEFAULT_KEYS: anycopyKeyConfig = {
-	toggleSelect: "space",
+	toggleSelect: "shift+a",
 	copy: "shift+c",
 	clear: "shift+x",
 	toggleLabelTimestamps: "shift+t",
@@ -81,6 +93,7 @@ const DEFAULT_KEYS: anycopyKeyConfig = {
 };
 
 const DEFAULT_TREE_FILTER_MODE: TreeFilterMode = "default";
+const DEFAULT_PERSIST_FOLD_STATE = true;
 
 const getExtensionDir = (): string => {
 	// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
@@ -116,6 +129,7 @@ const loadConfig = (): anycopyRuntimeConfig => {
 		return {
 			keys: { ...DEFAULT_KEYS },
 			treeFilterMode: DEFAULT_TREE_FILTER_MODE,
+			persistFoldState: DEFAULT_PERSIST_FOLD_STATE,
 		};
 	}
 
@@ -129,6 +143,8 @@ const loadConfig = (): anycopyRuntimeConfig => {
 			typeof treeFilterModeRaw === "string" && validTreeFilterModes.includes(treeFilterModeRaw as TreeFilterMode)
 				? (treeFilterModeRaw as TreeFilterMode)
 				: DEFAULT_TREE_FILTER_MODE;
+		const persistFoldState =
+			typeof parsed.persistFoldState === "boolean" ? parsed.persistFoldState : DEFAULT_PERSIST_FOLD_STATE;
 
 		return {
 			keys: {
@@ -145,11 +161,13 @@ const loadConfig = (): anycopyRuntimeConfig => {
 				pageUp: typeof keys.pageUp === "string" ? keys.pageUp : DEFAULT_KEYS.pageUp,
 			},
 			treeFilterMode,
+			persistFoldState,
 		};
 	} catch {
 		return {
 			keys: { ...DEFAULT_KEYS },
 			treeFilterMode: DEFAULT_TREE_FILTER_MODE,
+			persistFoldState: DEFAULT_PERSIST_FOLD_STATE,
 		};
 	}
 };
@@ -473,6 +491,10 @@ class anycopyOverlay implements Focusable {
 		private getTree: () => SessionTreeNode[],
 		private nodeById: Map<string, SessionTreeNode>,
 		private keys: anycopyKeyConfig,
+		private onExplicitFoldMutation: ((
+			beforeTransientFoldedNodeIds: string[],
+			afterTransientFoldedNodeIds: string[],
+		) => void) | null,
 		private onClose: () => void,
 		private getTermHeight: () => number,
 		private requestRender: () => void,
@@ -539,7 +561,18 @@ class anycopyOverlay implements Focusable {
 			return;
 		}
 
+		const keybindings = getKeybindings();
+		const shouldTrackExplicitFoldMutation =
+			this.onExplicitFoldMutation !== null &&
+			(keybindings.matches(data, "app.tree.foldOrUp") || keybindings.matches(data, "app.tree.unfoldOrDown"));
+		const beforeTransientFoldedNodeIds = shouldTrackExplicitFoldMutation ? getSelectorFoldedNodeIds(this.selector) : null;
+
 		this.selector.handleInput(data);
+
+		if (beforeTransientFoldedNodeIds) {
+			this.onExplicitFoldMutation?.(beforeTransientFoldedNodeIds, getSelectorFoldedNodeIds(this.selector));
+		}
+
 		this.requestRender();
 	}
 
@@ -783,6 +816,7 @@ export default function anycopyExtension(pi: ExtensionAPI) {
 	const config = loadConfig();
 	const keys = config.keys;
 	const treeFilterMode = config.treeFilterMode;
+	const persistFoldState = config.persistFoldState;
 
 	const openAnycopy = async (
 		ctx: ExtensionCommandContext,
@@ -812,6 +846,13 @@ export default function anycopyExtension(pi: ExtensionAPI) {
 		await ctx.ui.custom<void>((tui, theme, _kb, done) => {
 			const termRows = tui.terminal?.rows ?? 40;
 			const treeTermHeight = Math.floor(termRows * 0.65);
+			const nodeById = buildNodeMap(initialTree);
+			const validNodeIds = new Set(nodeById.keys());
+			const restoredFoldState = persistFoldState
+				? loadLatestFoldStateFromEntries(ctx.sessionManager.getEntries() as SessionEntry[], validNodeIds)
+				: null;
+			let durableFoldedNodeIds = restoredFoldState?.foldedNodeIds ?? [];
+			let lastPersistedFoldedNodeIds = durableFoldedNodeIds;
 
 			const selector = new TreeSelectorComponent(
 				initialTree,
@@ -844,14 +885,60 @@ export default function anycopyExtension(pi: ExtensionAPI) {
 				opts?.initialSelectedId,
 				treeFilterMode,
 			);
-			const effectiveLeafIdForNoop = selector.getTreeList().getSelectedNode()?.entry.id ?? currentLeafId;
 
-			const nodeById = buildNodeMap(initialTree);
+			if (persistFoldState) {
+				const restoredFoldedNodeIds = normalizeFoldedNodeIds(
+					setSelectorFoldedNodeIds(selector, durableFoldedNodeIds),
+					validNodeIds,
+				);
+				durableFoldedNodeIds = restoredFoldedNodeIds;
+				lastPersistedFoldedNodeIds = restoredFoldedNodeIds;
+			}
+
+			const persistDurableFoldState = (nextDurableFoldedNodeIds: string[]): void => {
+				if (!persistFoldState || foldStateNodeIdListsEqual(nextDurableFoldedNodeIds, lastPersistedFoldedNodeIds)) {
+					return;
+				}
+
+				try {
+					pi.appendEntry(
+						ANYCOPY_FOLD_STATE_CUSTOM_TYPE,
+						createFoldStateEntryData(nextDurableFoldedNodeIds, validNodeIds),
+					);
+					lastPersistedFoldedNodeIds = nextDurableFoldedNodeIds;
+				} catch (error) {
+					ctx.ui.notify(
+						error instanceof Error ? error.message : "Failed to persist /anycopy fold state",
+						"error",
+					);
+				}
+			};
+
+			const handleExplicitFoldMutation = (
+				beforeTransientFoldedNodeIds: string[],
+				afterTransientFoldedNodeIds: string[],
+			): void => {
+				const nextDurableFoldedNodeIds = mergeExplicitFoldMutation({
+					durableFoldedNodeIds,
+					beforeTransientFoldedNodeIds,
+					afterTransientFoldedNodeIds,
+					validNodeIds,
+				});
+				if (foldStateNodeIdListsEqual(nextDurableFoldedNodeIds, durableFoldedNodeIds)) {
+					return;
+				}
+
+				durableFoldedNodeIds = nextDurableFoldedNodeIds;
+				persistDurableFoldState(nextDurableFoldedNodeIds);
+			};
+
+			const effectiveLeafIdForNoop = selector.getTreeList().getSelectedNode()?.entry.id ?? currentLeafId;
 			const overlay = new anycopyOverlay(
 				selector,
 				getTree,
 				nodeById,
 				keys,
+				persistFoldState ? handleExplicitFoldMutation : null,
 				() => done(),
 				() => tui.terminal?.rows ?? 40,
 				() => tui.requestRender(),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-anycopy",
-  "version": "0.2.1",
-  "description": "Pi's /tree with a live syntax-highlighted preview and ability to copy any node(s) to the clipboard",
+  "version": "0.2.3",
+  "description": "Pi's /tree with a live syntax-highlighted preview, ability to copy any node(s) to the clipboard, and persistence of folded branches",
   "keywords": ["pi-package", "pi", "pi-coding-agent"],
   "license": "MIT",
   "repository": {
@@ -29,6 +29,7 @@
     "copy": [
       { "from": "../../extensions/anycopy/index.ts", "to": "extensions/anycopy/index.ts" },
       { "from": "../../extensions/anycopy/enter-navigation.ts", "to": "extensions/anycopy/enter-navigation.ts" },
+      { "from": "../../extensions/anycopy/fold-state.ts", "to": "extensions/anycopy/fold-state.ts" },
       { "from": "../../extensions/anycopy/config.json", "to": "extensions/anycopy/config.json" },
       { "from": "../../LICENSE", "to": "LICENSE" }
     ],