pi-cc-extensions 0.8.31 → 0.8.32

package/extensions/compact-thinking.ts

@@ -0,0 +1,58 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createJiti } from "jiti";
+
+export type CompactThinkingConfig = {
+	useSummaryTitlesAsThinkingTitle: boolean;
+	previewLines: number;
+	animationIntervalMs: number;
+};
+
+export type CompactThinkingController = {
+	updateConfig(next: CompactThinkingConfig): void;
+};
+
+export function installCompactThinking(
+	pi: ExtensionAPI,
+	initialConfig: CompactThinkingConfig,
+): CompactThinkingController {
+	const agentDir = process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
+	const configPath = join(agentDir, "compact-thinking.json");
+	let hasValidCompatibilityConfig = false;
+	try {
+		const value = JSON.parse(readFileSync(configPath, "utf8")) as Partial<CompactThinkingConfig>;
+		hasValidCompatibilityConfig =
+			typeof value.useSummaryTitlesAsThinkingTitle === "boolean" &&
+			Number.isInteger(value.previewLines) &&
+			(value.previewLines ?? -1) >= 0 &&
+			Number.isFinite(value.animationIntervalMs) &&
+			(value.animationIntervalMs ?? 0) >= 1;
+	} catch {
+		// The upstream loader needs a valid compatibility file on first install.
+	}
+	if (!hasValidCompatibilityConfig) {
+		if (!existsSync(agentDir)) mkdirSync(agentDir, { recursive: true });
+		writeFileSync(configPath, `${JSON.stringify(initialConfig, null, 2)}\n`, "utf8");
+	}
+
+	// The package publishes TypeScript source only, so use the loader already used by fixed-editor.
+	const jiti = createJiti(import.meta.url);
+	const upstreamConfig = (
+		jiti("pi-compact-thinking/lib/config.ts") as { config: CompactThinkingConfig }
+	).config;
+	const compactThinking = (
+		jiti("pi-compact-thinking/index.ts") as {
+			default: (api: ExtensionAPI) => void;
+		}
+	).default;
+	Object.assign(upstreamConfig, initialConfig);
+	compactThinking(pi);
+
+	return {
+		updateConfig(next) {
+			Object.assign(upstreamConfig, next);
+		},
+	};
+}

package/extensions/fixed-editor.ts

@@ -0,0 +1,185 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { createJiti } from "jiti";
+
+type LifecycleHandler = (event: any, ctx: any) => void;
+type FixedEditorExtension = (pi: ExtensionAPI) => void;
+
+// The npm package publishes TypeScript source only, so use Pi's own TS loader.
+const jiti = createJiti(import.meta.url);
+// Match pi-fixed-editor's own `.js` import specifier; Jiti caches `.ts` separately.
+const terminalSplit = jiti("@tifan/pi-fixed-editor/src/terminal-split.js") as {
+	TerminalSplitCompositor?: { prototype: Record<PropertyKey, any> };
+};
+export type FixedEditorHitbox = { row: number; startCol: number; endCol: number };
+
+type FixedEditorSharedState = { scrollButtonHitbox: FixedEditorHitbox | null };
+const FIXED_EDITOR_STATE_KEY = Symbol.for("pi.ccstyle.fixed-editor.state");
+const fixedEditorState = (() => {
+	const host = globalThis as typeof globalThis & {
+		[FIXED_EDITOR_STATE_KEY]?: FixedEditorSharedState;
+	};
+	host[FIXED_EDITOR_STATE_KEY] ??= { scrollButtonHitbox: null };
+	return host[FIXED_EDITOR_STATE_KEY];
+})();
+
+export function getFixedEditorScrollButtonHitbox(): FixedEditorHitbox | null {
+	return fixedEditorState.scrollButtonHitbox;
+}
+
+const FIXED_EDITOR_SPACING_PATCH = Symbol.for("pi.ccstyle.fixed-editor-spacing-patch");
+const clusterModule = jiti("@tifan/pi-fixed-editor/src/cluster.js") as {
+	renderFixedEditorCluster?: (input: any) => any;
+};
+if (!(clusterModule as any)[FIXED_EDITOR_SPACING_PATCH] && clusterModule.renderFixedEditorCluster) {
+	const renderCluster = clusterModule.renderFixedEditorCluster;
+	const padWidgets = (lines: string[] | undefined) =>
+		lines?.map((line) => (line.length > 0 && !line.includes("Ctrl+End") ? ` ${line}` : line));
+	clusterModule.renderFixedEditorCluster = (input) => {
+		const aboveWidgetLines = padWidgets(input.aboveWidgetLines);
+		const result = renderCluster({
+			...input,
+			// pi-fixed-editor strips Pi's leading widget spacer; restore it below the spinner.
+			aboveWidgetLines:
+				input.statusLines?.length && aboveWidgetLines?.length
+					? ["", ...aboveWidgetLines]
+					: aboveWidgetLines,
+			belowWidgetLines: padWidgets(input.belowWidgetLines),
+		});
+		const buttonRow = result.lines.findIndex((line: string) => line.includes("Ctrl+End"));
+		if (buttonRow < 0) {
+			fixedEditorState.scrollButtonHitbox = null;
+		} else {
+			const plain = result.lines[buttonRow]
+				.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+				.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
+			const start = plain.indexOf("[");
+			fixedEditorState.scrollButtonHitbox = {
+				row: input.terminalRows - result.lines.length + buttonRow + 1,
+				startCol: visibleWidth(plain.slice(0, Math.max(0, start))) + 1,
+				endCol: visibleWidth(plain.trimEnd()),
+			};
+		}
+		return result;
+	};
+	(clusterModule as any)[FIXED_EDITOR_SPACING_PATCH] = true;
+}
+const loaded = jiti("@tifan/pi-fixed-editor/src/index.ts") as {
+	default?: FixedEditorExtension;
+};
+const fixedEditor = loaded.default ?? (loaded as unknown as FixedEditorExtension);
+
+const IME_CURSOR_PATCH = Symbol.for("pi.ccstyle.fixed-editor-ime-cursor-patch");
+
+function positionHiddenImeCursor(compositor: any): void {
+	if (
+		compositor.disposed ||
+		compositor.writing ||
+		compositor.getShowHardwareCursor?.() ||
+		compositor.hasVisibleOverlay?.()
+	)
+		return;
+	const rows = compositor.getRawRows?.();
+	if (!Number.isFinite(rows)) return;
+	const width = Math.max(1, Number(compositor.terminal?.columns) || 80);
+	const cluster = compositor.getCluster?.(width, rows);
+	if (!cluster?.cursor) return;
+	const row = Math.max(1, rows - cluster.lines.length + cluster.cursor.row + 1);
+	const col = Math.max(1, cluster.cursor.col + 1);
+	compositor.originalWrite?.(`\x1b[?2026h\x1b[${row};${col}H\x1b[?25l\x1b[?2026l`);
+}
+
+export function installFixedEditorImePatch(compositorClass: {
+	prototype: Record<PropertyKey, any>;
+}): void {
+	const prototype = compositorClass.prototype;
+	if (prototype[IME_CURSOR_PATCH]) return;
+	for (const name of ["write", "requestRepaint"] as const) {
+		const original = prototype[name];
+		if (typeof original !== "function") continue;
+		prototype[name] = function (this: any, ...args: any[]) {
+			const result = Reflect.apply(original, this, args);
+			positionHiddenImeCursor(this);
+			return result;
+		};
+	}
+	prototype[IME_CURSOR_PATCH] = true;
+}
+
+if (terminalSplit.TerminalSplitCompositor) {
+	installFixedEditorImePatch(terminalSplit.TerminalSplitCompositor);
+}
+
+export type FixedEditorController = {
+	setEnabled(enabled: boolean): void;
+};
+
+type FixedEditorOwner = {
+	owner: object;
+	stop: () => void;
+};
+
+const FIXED_EDITOR_OWNER = Symbol.for("pi.ccstyle.fixed-editor-owner");
+
+/** Adds runtime on/off control around pi-fixed-editor's session lifecycle. */
+export function installFixedEditor(
+	pi: ExtensionAPI,
+	initiallyEnabled: boolean,
+): FixedEditorController {
+	let start: LifecycleHandler | undefined;
+	let shutdown: LifecycleHandler | undefined;
+	fixedEditor({
+		on(event: string, handler: LifecycleHandler) {
+			if (event === "session_start") start = handler;
+			if (event === "session_shutdown") shutdown = handler;
+		},
+	} as unknown as ExtensionAPI);
+
+	const owner = {};
+	let enabled = initiallyEnabled;
+	let active = false;
+	let session: { event: any; ctx: any } | undefined;
+
+	const deactivate = () => {
+		fixedEditorState.scrollButtonHitbox = null;
+		const current = (globalThis as any)[FIXED_EDITOR_OWNER] as FixedEditorOwner | undefined;
+		if (current?.owner === owner) current.stop();
+		else active = false;
+	};
+	const activate = () => {
+		if (!session || session.ctx?.mode !== "tui" || active) return;
+		const previous = (globalThis as any)[FIXED_EDITOR_OWNER] as FixedEditorOwner | undefined;
+		if (previous?.owner !== owner) previous?.stop();
+		const currentSession = session;
+		start?.(currentSession.event, currentSession.ctx);
+		active = true;
+		(globalThis as any)[FIXED_EDITOR_OWNER] = {
+			owner,
+			stop: () => {
+				if (!active) return;
+				shutdown?.(currentSession.event, currentSession.ctx);
+				active = false;
+				if ((globalThis as any)[FIXED_EDITOR_OWNER]?.owner === owner) {
+					delete (globalThis as any)[FIXED_EDITOR_OWNER];
+				}
+			},
+		} satisfies FixedEditorOwner;
+	};
+
+	pi.on("session_start", (event, ctx) => {
+		session = { event, ctx };
+		if (enabled) activate();
+	});
+	pi.on("session_shutdown", () => {
+		deactivate();
+		session = undefined;
+	});
+
+	return {
+		setEnabled(nextEnabled) {
+			enabled = nextEnabled;
+			if (nextEnabled) activate();
+			else deactivate();
+		},
+	};
+}

package/extensions/index.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import agentAutocomplete from "./agent-autocomplete.ts";
-import askUserQuestion from "./ask-user-question/index.ts";
-import claudeCodeStyle from "./claude-code-style.ts";
+import claudeCodeStyle, { getCompactThinkingConfig } from "./claude-code-style.ts";
+import { installCompactThinking, type CompactThinkingController } from "./compact-thinking.ts";
 import context from "./context.ts";
 import piAliases from "./pi-aliases.ts";
 import piStartupHeader from "./pi-startup-header.ts";
@@ -12,11 +12,17 @@ import workingMessage from "./working-message.ts";
 export default function (pi: ExtensionAPI): void {
 	piAliases(pi);
 	piStartupHeader(pi);
-	claudeCodeStyle(pi);
+	let compactThinking: CompactThinkingController | undefined;
+	const compactThinkingBridge: CompactThinkingController = {
+		updateConfig(next) {
+			compactThinking?.updateConfig(next);
+		},
+	};
+	claudeCodeStyle(pi, undefined, compactThinkingBridge);
+	compactThinking = installCompactThinking(pi, getCompactThinkingConfig());
 	subagentNotification(pi);
 	workingMessage(pi);
 	context(pi);
 	sessionReference(pi);
 	agentAutocomplete(pi);
-	askUserQuestion(pi);
 }

package/node_modules/@tifan/pi-fixed-editor/README.md

@@ -0,0 +1,36 @@
+# @tifan/pi-fixed-editor
+
+Keep Pi's editor, footer, and editor-adjacent widgets fixed at the bottom of the terminal while the transcript scrolls.
+
+## Install
+
+```bash
+pi install npm:@tifan/pi-fixed-editor
+```
+
+## What it does
+
+- Pins Pi's existing editor/footer area to the bottom of the terminal.
+- Keeps `aboveEditor` and `belowEditor` widgets with the editor.
+- Preserves existing editor behavior, footer content, and autocomplete.
+- Routes mouse wheel and PageUp/PageDown scrolling to the transcript.
+- Jumps the transcript back to the bottom when you submit a query with Enter.
+
+## What it does not do
+
+- No styling.
+- No powerline footer.
+- No commands.
+- No settings.
+- No custom shortcuts.
+- No print or RPC mode behavior.
+
+Uninstall or disable the extension to return to Pi's default scrolling behavior.
+
+## Credits
+
+Fixed terminal-region behavior is adapted from [pi-powerline-footer](https://github.com/nicobailon/pi-powerline-footer) by Nico Bailon.
+
+## License
+
+[MIT](LICENSE)

package/node_modules/@tifan/pi-fixed-editor/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@tifan/pi-fixed-editor",
+  "version": "0.2.5",
+  "description": "Keep the pi editor and footer fixed while the transcript scrolls.",
+  "keywords": [
+    "fixed-editor",
+    "pi",
+    "pi-extension",
+    "pi-package",
+    "terminal"
+  ],
+  "homepage": "https://github.com/tifandotme/pi-extensions/tree/master/packages/pi-fixed-editor#readme",
+  "bugs": "https://github.com/tifandotme/pi-extensions/issues",
+  "license": "MIT",
+  "author": "Tifan Dwi Avianto <hi@tifan.me>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tifandotme/pi-extensions.git",
+    "directory": "packages/pi-fixed-editor"
+  },
+  "files": [
+    "src/**/*.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "test": "node --experimental-strip-types --test tests/**/*.test.ts"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=0.78.0",
+    "@earendil-works/pi-tui": ">=0.78.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  }
+}

package/node_modules/@tifan/pi-fixed-editor/src/cluster.ts

@@ -0,0 +1,113 @@
+import {
+  CURSOR_MARKER,
+  truncateToWidth,
+  visibleWidth,
+} from "@earendil-works/pi-tui"
+
+export interface FixedEditorClusterInput {
+  width: number
+  terminalRows: number
+  statusLines?: string[]
+  aboveWidgetLines?: string[]
+  editorLines: string[]
+  belowWidgetLines?: string[]
+  footerLines?: string[]
+}
+
+export interface FixedEditorCursor {
+  row: number
+  col: number
+}
+
+export interface FixedEditorClusterRender {
+  lines: string[]
+  cursor: FixedEditorCursor | null
+}
+
+function normalizeLines(lines: string[] | undefined, width: number): string[] {
+  if (!lines || width <= 0) return []
+
+  return lines
+    .filter((line) => line !== undefined && line !== null)
+    .map((line) =>
+      visibleWidth(line) > width
+        ? truncateToWidth(line, width, "", true)
+        : line,
+    )
+}
+
+function takeTail(lines: string[], count: number): string[] {
+  if (count <= 0) return []
+  return lines.length <= count ? lines : lines.slice(lines.length - count)
+}
+
+function capEditorLines(lines: string[], count: number): string[] {
+  if (count <= 0) return []
+  if (lines.length <= count) return lines
+
+  const cursorRow = lines.findIndex((line) => line.includes(CURSOR_MARKER))
+  if (cursorRow !== -1) {
+    const start = Math.max(
+      0,
+      Math.min(cursorRow - count + 1, lines.length - count),
+    )
+    return lines.slice(start, start + count)
+  }
+
+  return lines.slice(lines.length - count)
+}
+
+function extractCursor(lines: string[]): FixedEditorClusterRender {
+  let cursor: FixedEditorCursor | null = null
+  const cleaned = lines.map((line, row) => {
+    const markerIndex = line.indexOf(CURSOR_MARKER)
+    if (markerIndex === -1) return line
+
+    cursor ??= {
+      row,
+      col: visibleWidth(line.slice(0, markerIndex)),
+    }
+
+    return (
+      line.slice(0, markerIndex) +
+      line.slice(markerIndex + CURSOR_MARKER.length)
+    )
+  })
+
+  return { lines: cleaned, cursor }
+}
+
+export function renderFixedEditorCluster(
+  input: FixedEditorClusterInput,
+): FixedEditorClusterRender {
+  const width = Math.max(1, input.width)
+  const maxRows = Math.max(1, input.terminalRows - 1)
+
+  const statusLines = normalizeLines(input.statusLines, width)
+  const aboveWidgetLines = normalizeLines(input.aboveWidgetLines, width)
+  const editorSource = normalizeLines(input.editorLines, width)
+  const belowWidgetLines = normalizeLines(input.belowWidgetLines, width)
+  const footerLines = normalizeLines(input.footerLines, width)
+
+  const editorLines = capEditorLines(editorSource, maxRows)
+  let remaining = maxRows - editorLines.length
+
+  const footer = takeTail(footerLines, remaining)
+  remaining -= footer.length
+
+  const belowWidgets = takeTail(belowWidgetLines, remaining)
+  remaining -= belowWidgets.length
+
+  const aboveWidgets = takeTail(aboveWidgetLines, remaining)
+  remaining -= aboveWidgets.length
+
+  const status = takeTail(statusLines, remaining)
+
+  return extractCursor([
+    ...status,
+    ...aboveWidgets,
+    ...editorLines,
+    ...belowWidgets,
+    ...footer,
+  ])
+}