@bdsqqq/pi 0.0.1

package/dist/core/tui.d.ts

@@ -0,0 +1,9 @@
+//#region packages/core/tui/index.d.ts
+/** lazy Text constructor — call getText() to get the Text class, then instantiate */
+declare function getText(): new (text: string, paddingX: number, paddingY: number) => any;
+/** lazy Container constructor */
+declare function getContainer(): new (...args: any[]) => any;
+/** lazy Markdown constructor */
+declare function getMarkdown(): new (...args: any[]) => any;
+//#endregion
+export { getContainer, getMarkdown, getText };

package/dist/core/tui.js

@@ -0,0 +1,33 @@
+import { n as __require } from "../chunk-DsIazq42.js";
+//#region packages/core/tui/index.ts
+/**
+* lazy re-exports of @mariozechner/pi-tui components.
+*
+* pi-tui is provided by pi's runtime and isn't resolvable in
+* standalone test environments (bun test). lazy-loading via
+* require() defers resolution to first use — which only happens
+* inside renderCall/renderResult at runtime, never during
+* execute()-only tests.
+*
+* usage: import { getText, getContainer } from "@bds_pi/tui";
+*        return getText()("hello", 0, 0);
+*/
+let _piTui;
+function tui() {
+	if (!_piTui) _piTui = __require("@mariozechner/pi-tui");
+	return _piTui;
+}
+/** lazy Text constructor — call getText() to get the Text class, then instantiate */
+function getText() {
+	return tui().Text;
+}
+/** lazy Container constructor */
+function getContainer() {
+	return tui().Container;
+}
+/** lazy Markdown constructor */
+function getMarkdown() {
+	return tui().Markdown;
+}
+//#endregion
+export { getContainer, getMarkdown, getText };

package/dist/editor-BljciPdx.js

@@ -0,0 +1,537 @@
+import { boxBorderLR, boxRow } from "./core/box-chrome.js";
+import { hasToolCost } from "./core/tool-cost.js";
+import { execFile } from "node:child_process";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { CustomEditor, estimateTokens } from "@mariozechner/pi-coding-agent";
+import { promisify } from "node:util";
+//#region packages/extensions/editor/widget-row.ts
+var WidgetRowRegistry = class {
+	segments = /* @__PURE__ */ new Map();
+	_version = 0;
+	constructor(tui) {
+		this.tui = tui;
+	}
+	get version() {
+		return this._version;
+	}
+	set(id, segment) {
+		this.segments.set(id, segment);
+		this._version++;
+		this.tui.requestRender();
+	}
+	remove(id) {
+		if (this.segments.delete(id)) {
+			this._version++;
+			this.tui.requestRender();
+		}
+	}
+	clear() {
+		if (this.segments.size === 0) return;
+		this.segments.clear();
+		this._version++;
+		this.tui.requestRender();
+	}
+	snapshot() {
+		return [...this.segments.values()];
+	}
+};
+function sortByPriority(children) {
+	return [...children].sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+}
+function joinGroup(children, width, gap) {
+	if (children.length === 0) return "";
+	return sortByPriority(children).map((child) => child.renderInline(width)).filter((part) => part.length > 0).join(gap);
+}
+function clampToWidth(text, maxWidth) {
+	if (maxWidth <= 0) return "";
+	return truncateToWidth(text, maxWidth);
+}
+function layoutLine(children, width, gap) {
+	if (width <= 0) return "";
+	const grouped = {
+		left: [],
+		center: [],
+		right: []
+	};
+	for (const child of children) grouped[child.align].push(child);
+	let left = joinGroup(grouped.left, width, gap);
+	let center = joinGroup(grouped.center, width, gap);
+	let right = joinGroup(grouped.right, width, gap);
+	let leftWidth = visibleWidth(left);
+	let centerWidth = visibleWidth(center);
+	let rightWidth = visibleWidth(right);
+	const shrinkCenter = () => {
+		const budget = Math.max(0, width - leftWidth - rightWidth);
+		if (centerWidth > budget) {
+			center = clampToWidth(center, budget);
+			centerWidth = visibleWidth(center);
+		}
+	};
+	shrinkCenter();
+	if (leftWidth + rightWidth > width) {
+		const leftBudget = Math.max(0, width - rightWidth);
+		if (leftWidth > leftBudget) {
+			left = clampToWidth(left, leftBudget);
+			leftWidth = visibleWidth(left);
+		}
+	}
+	if (leftWidth + rightWidth > width) {
+		const rightBudget = Math.max(0, width - leftWidth);
+		if (rightWidth > rightBudget) {
+			right = clampToWidth(right, rightBudget);
+			rightWidth = visibleWidth(right);
+		}
+	}
+	const availableCenter = Math.max(0, width - leftWidth - rightWidth);
+	if (centerWidth > availableCenter) {
+		center = clampToWidth(center, availableCenter);
+		centerWidth = visibleWidth(center);
+	}
+	const paddingForCenter = Math.max(0, availableCenter - centerWidth);
+	const padLeft = Math.floor(paddingForCenter / 2);
+	const padRight = paddingForCenter - padLeft;
+	return truncateToWidth(left + " ".repeat(padLeft) + center + " ".repeat(padRight) + right, width);
+}
+var HorizontalLineWidget = class {
+	cachedWidth;
+	cachedLines;
+	cachedVersion;
+	constructor(getChildren, options = {}, getVersion) {
+		this.getChildren = getChildren;
+		this.options = options;
+		this.getVersion = getVersion;
+	}
+	invalidate() {
+		this.cachedWidth = void 0;
+		this.cachedLines = void 0;
+		this.cachedVersion = void 0;
+	}
+	render(width) {
+		const version = this.getVersion?.();
+		if (this.cachedLines && this.cachedWidth === width && (!this.getVersion || version != null && this.cachedVersion === version)) return this.cachedLines;
+		const lines = [layoutLine(this.getChildren(), width, this.options.gap ?? "  ")];
+		this.cachedWidth = width;
+		this.cachedLines = lines;
+		this.cachedVersion = version;
+		return lines;
+	}
+};
+//#endregion
+//#region packages/extensions/editor/index.ts
+const execFileAsync = promisify(execFile);
+const SEPARATOR = " · ";
+const HORIZONTAL = "─";
+var LabeledEditor = class extends CustomEditor {
+	labels = /* @__PURE__ */ new Map();
+	appTheme;
+	borderCache = {
+		top: null,
+		bottom: null
+	};
+	constructor(tui, editorTheme, keybindings, appTheme) {
+		super(tui, editorTheme, keybindings);
+		this.appTheme = appTheme;
+	}
+	/** always-dim color for box chrome (corners, lines, rails) */
+	dim(str) {
+		return this.appTheme.fg("dim", str);
+	}
+	setLabel(key, text, position = "top", align = "left") {
+		this.labels.set(key, {
+			key,
+			text,
+			position,
+			align
+		});
+	}
+	removeLabel(key) {
+		this.labels.delete(key);
+	}
+	getLabelsFor(position, align) {
+		const matching = [...this.labels.values()].filter((l) => l.position === position && l.align === align);
+		if (matching.length === 0) return "";
+		return matching.map((l) => l.text).join(SEPARATOR);
+	}
+	extractScrollIndicator(originalLine) {
+		if (!originalLine.includes("↑") && !originalLine.includes("↓")) return "";
+		const match = originalLine.match(/[↑↓]\s+\d+\s+more/);
+		return match ? match[0] : "";
+	}
+	/**
+	* build a border line like: ╭─ left label ─────── right label ─╮
+	*
+	* inherits scroll indicator text from the original border line if present.
+	* delegates chrome layout to boxBorderLR; caching stays here.
+	*/
+	buildBorderLine(outerWidth, corner, position, originalLine) {
+		const leftText = this.getLabelsFor(position, "left");
+		const rightCombined = [this.getLabelsFor(position, "right"), this.extractScrollIndicator(originalLine)].filter(Boolean).join(SEPARATOR);
+		const cacheKey = `${outerWidth}|${position}|${leftText}|${rightCombined}`;
+		const cached = this.borderCache[position];
+		if (cached?.key === cacheKey) return cached.line;
+		const line = boxBorderLR({
+			corner,
+			style: { dim: (s) => this.dim(s) },
+			innerWidth: outerWidth - 2,
+			left: leftText ? {
+				text: leftText,
+				width: visibleWidth(leftText)
+			} : void 0,
+			right: rightCombined ? {
+				text: rightCombined,
+				width: visibleWidth(rightCombined)
+			} : void 0
+		});
+		this.borderCache[position] = {
+			key: cacheKey,
+			line
+		};
+		return line;
+	}
+	/**
+	* find the bottom border index in the lines array from super.render().
+	* the bottom border is a full-width line of ─ characters (possibly with a scroll indicator).
+	* autocomplete lines appear after it and contain mixed content (not all ─).
+	*
+	* strategy: walk backward from the end, looking for a line whose stripped content
+	* is predominantly ─ characters. the first such line (from the end) is the bottom border.
+	*/
+	findBottomBorderIndex(lines) {
+		for (let i = lines.length - 1; i >= 1; i--) {
+			const line = lines[i];
+			if (!line) continue;
+			const stripped = line.replace(/\x1b\[[0-9;]*[mGKHJ]/g, "").replace(/\x1b_[^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\x1b\]8;;[^\x07]*\x07/g, "");
+			if (stripped.length > 0 && stripped[0] === HORIZONTAL) return i;
+		}
+		return lines.length - 1;
+	}
+	render(width) {
+		const innerWidth = width - 2;
+		if (innerWidth < 4) return super.render(width);
+		const lines = super.render(innerWidth);
+		if (lines.length < 2) return lines;
+		const bottomIdx = this.findBottomBorderIndex(lines);
+		const result = [];
+		const chrome = { dim: (s) => this.dim(s) };
+		result.push(this.buildBorderLine(width, {
+			left: "╭",
+			right: "╮"
+		}, "top", lines[0]));
+		for (let i = 1; i < bottomIdx; i++) result.push(boxRow({
+			variant: "closed",
+			style: chrome,
+			inner: lines[i]
+		}));
+		result.push(this.buildBorderLine(width, {
+			left: "╰",
+			right: "╯"
+		}, "bottom", lines[bottomIdx]));
+		for (let i = bottomIdx + 1; i < lines.length; i++) result.push(" " + lines[i] + " ");
+		return result;
+	}
+};
+function formatTokens(n) {
+	if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+	return String(n);
+}
+function shortenPath(cwd) {
+	const home = process.env.HOME || process.env.USERPROFILE || "";
+	if (home && cwd.startsWith(home)) return "~" + cwd.slice(home.length);
+	return cwd;
+}
+/**
+* estimate context tokens from session entries using chars/4 heuristic.
+* fallback when provider hasn't reported usage yet (e.g., after compaction).
+*/
+function estimateContextFromEntries(entries) {
+	let total = 0;
+	for (const entry of entries) switch (entry.type) {
+		case "message":
+			total += estimateTokens(entry.message);
+			break;
+		case "custom_message": {
+			const content = entry.content;
+			const text = typeof content === "string" ? content : content.filter((c) => c.type === "text").map((c) => c.text).join("");
+			total += Math.ceil(text.length / 4);
+			break;
+		}
+		case "branch_summary":
+			if (entry.summary) total += Math.ceil(entry.summary.length / 4);
+			break;
+		case "compaction":
+			if (entry.summary) total += Math.ceil(entry.summary.length / 4);
+			break;
+	}
+	return total;
+}
+function updateStatsLabels(editor, pi, ctx, cachedLen) {
+	if (!editor) return;
+	const branch = ctx.sessionManager.getBranch();
+	if (cachedLen && branch.length === cachedLen.value) return;
+	if (cachedLen) cachedLen.value = branch.length;
+	const usage = ctx.getContextUsage();
+	const model = ctx.model;
+	let cost = 0;
+	for (const entry of branch) {
+		if (entry.type !== "message") continue;
+		const msg = entry.message;
+		if (msg.role === "assistant") cost += msg.usage?.cost?.total ?? 0;
+		else if (msg.role === "toolResult") {
+			const details = msg.details;
+			if (hasToolCost(details)) cost += details.cost;
+		}
+	}
+	const topLeftParts = [];
+	if (usage?.percent != null && usage.tokens != null && usage.tokens > 0) topLeftParts.push(`${Math.round(usage.percent)}% of ${formatTokens(usage.contextWindow)}`);
+	else if (model?.contextWindow) {
+		const percent = estimateContextFromEntries(branch) / model.contextWindow * 100;
+		topLeftParts.push(`~${Math.round(percent)}% of ${formatTokens(model.contextWindow)}`);
+	}
+	if (cost > 0) topLeftParts.push(`$${cost.toFixed(2)}`);
+	if (topLeftParts.length > 0) editor.setLabel("stats", topLeftParts.join(" · "), "top", "left");
+	const topRightParts = [];
+	if (model) {
+		const provider = model.provider ? `(${model.provider})` : "";
+		topRightParts.push(`${provider} ${model.id}`.trim());
+	}
+	const thinkingLevel = pi.getThinkingLevel();
+	if (thinkingLevel && thinkingLevel !== "off") topRightParts.push(thinkingLevel);
+	if (topRightParts.length > 0) editor.setLabel("model", topRightParts.join(" · "), "top", "right");
+}
+async function getGitDiffStats(cwd) {
+	try {
+		const { stdout } = await execFileAsync("git", ["diff", "--stat"], {
+			cwd,
+			timeout: 3e3
+		});
+		const out = stdout.trim();
+		if (!out) return "";
+		const lines = out.split("\n");
+		const summary = lines[lines.length - 1];
+		if (!summary) return "";
+		const filesMatch = summary.match(/(\d+)\s+files?\s+changed/);
+		const insMatch = summary.match(/(\d+)\s+insertions?\(\+\)/);
+		const delMatch = summary.match(/(\d+)\s+deletions?\(-\)/);
+		if (!filesMatch) return "";
+		const parts = [`${filesMatch[1]} files changed`];
+		if (insMatch) parts.push(`+${insMatch[1]}`);
+		if (delMatch) parts.push(`-${delMatch[1]}`);
+		return parts.join(" ");
+	} catch {
+		return "";
+	}
+}
+const SPINNER_FRAMES = [
+	"·",
+	"•",
+	"*",
+	"⁑",
+	"⁂",
+	"⁑",
+	"*",
+	"•",
+	"·"
+];
+function createActivityState() {
+	return {
+		phase: "idle",
+		turnIndex: 0,
+		activeTools: /* @__PURE__ */ new Map(),
+		startedAt: 0,
+		intervalId: null,
+		frame: 0
+	};
+}
+function formatElapsed(ms) {
+	const s = Math.floor(ms / 1e3);
+	if (s < 60) return `${s}s`;
+	const m = Math.floor(s / 60);
+	const rem = s % 60;
+	return `${m}m${rem > 0 ? `${rem}s` : ""}`;
+}
+/**
+* shorten a tool name for display: "tool_execution" → "tool_execution",
+* but we also extract a meaningful arg when possible (e.g. file path).
+*/
+function describeToolCall(toolName, args) {
+	const hint = args?.path ?? args?.pattern ?? args?.query ?? args?.filePattern ?? args?.cmd;
+	if (typeof hint === "string") return `${toolName}(${hint.includes("/") ? hint.split("/").pop() : hint.length > 24 ? hint.slice(0, 24) + "…" : hint})`;
+	return toolName;
+}
+function renderActivity(state) {
+	if (state.phase === "idle") return "";
+	const parts = [];
+	parts.push(SPINNER_FRAMES[state.frame % SPINNER_FRAMES.length]);
+	if (state.turnIndex > 0) parts.push(`turn ${state.turnIndex + 1}`);
+	if (state.activeTools.size > 0) {
+		const toolDescs = [...state.activeTools.values()];
+		const shown = toolDescs.slice(0, 2).join(", ");
+		const overflow = toolDescs.length > 2 ? ` +${toolDescs.length - 2}` : "";
+		parts.push(shown + overflow);
+	} else if (state.phase === "thinking") parts.push("thinking");
+	else if (state.phase === "streaming") parts.push("writing");
+	if (state.startedAt > 0) {
+		const elapsed = Date.now() - state.startedAt;
+		if (elapsed >= 1e3) parts.push(formatElapsed(elapsed));
+	}
+	return parts.join(" · ");
+}
+function editor_default(pi) {
+	let editor = null;
+	const statsCacheBranchLen = { value: -1 };
+	let gitBranch = null;
+	let branchUnsub = null;
+	let statusRow = null;
+	const activity = createActivityState();
+	pi.on("session_start", async (_event, ctx) => {
+		if (!ctx.hasUI) return;
+		const themeAny = ctx.ui.theme;
+		if (themeAny.bgColors instanceof Map) {
+			const transparent = "\x1B[49m";
+			themeAny.bgColors.set("toolPendingBg", transparent);
+			themeAny.bgColors.set("toolSuccessBg", transparent);
+			themeAny.bgColors.set("toolErrorBg", transparent);
+		}
+		ctx.ui.setEditorComponent((tui, editorTheme, keybindings) => {
+			editor = new LabeledEditor(tui, editorTheme, keybindings, ctx.ui.theme);
+			return editor;
+		});
+		ctx.ui.setFooter((tui, _theme, footerData) => {
+			gitBranch = footerData.getGitBranch();
+			branchUnsub = footerData.onBranchChange(() => {
+				gitBranch = footerData.getGitBranch();
+				updateBottomLabel();
+				tui.requestRender();
+			});
+			updateBottomLabel();
+			return {
+				dispose: () => {
+					branchUnsub?.();
+					branchUnsub = null;
+				},
+				invalidate() {},
+				render(_width) {
+					return [];
+				}
+			};
+		});
+		ctx.ui.setWidget("status-line", (tui) => {
+			statusRow = new WidgetRowRegistry(tui);
+			return new HorizontalLineWidget(() => statusRow.snapshot(), { gap: "  " }, () => statusRow.version);
+		}, { placement: "belowEditor" });
+		function updateBottomLabel() {
+			if (!editor) return;
+			const cwd = shortenPath(ctx.cwd);
+			const branchText = gitBranch ? `(${gitBranch})` : "";
+			editor.setLabel("cwd", `${cwd} ${branchText}`.trim(), "bottom", "right");
+		}
+		updateBottomLabel();
+		updateStatsLabels(editor, pi, ctx, statsCacheBranchLen);
+	});
+	const ACTIVITY_SEGMENT = "activity";
+	const GIT_SEGMENT = "git-changes";
+	/** push current activity state into the widget row */
+	const syncActivitySegment = () => {
+		if (activity.phase === "idle") {
+			statusRow?.remove(ACTIVITY_SEGMENT);
+			return;
+		}
+		if (!renderActivity(activity)) return;
+		statusRow?.set(ACTIVITY_SEGMENT, {
+			align: "left",
+			priority: 10,
+			renderInline: () => renderActivity(activity)
+		});
+	};
+	const startSpinner = () => {
+		if (activity.intervalId) return;
+		activity.intervalId = setInterval(() => {
+			activity.frame = (activity.frame + 1) % SPINNER_FRAMES.length;
+			syncActivitySegment();
+		}, 150);
+	};
+	const stopSpinner = () => {
+		if (activity.intervalId) {
+			clearInterval(activity.intervalId);
+			activity.intervalId = null;
+		}
+	};
+	const updateGitSegment = (text) => {
+		if (!text) {
+			statusRow?.remove(GIT_SEGMENT);
+			return;
+		}
+		statusRow?.set(GIT_SEGMENT, {
+			align: "right",
+			priority: 0,
+			renderInline: () => text
+		});
+	};
+	pi.on("agent_start", async (_event, ctx) => {
+		ctx.ui.setWorkingMessage(" ");
+		activity.phase = "thinking";
+		activity.turnIndex = 0;
+		activity.activeTools.clear();
+		activity.startedAt = Date.now();
+		activity.frame = 0;
+		startSpinner();
+		syncActivitySegment();
+	});
+	pi.on("turn_start", async (event, _ctx) => {
+		activity.turnIndex = event.turnIndex;
+		activity.phase = activity.activeTools.size > 0 ? "tool" : "thinking";
+		syncActivitySegment();
+	});
+	pi.on("tool_execution_start", async (event, _ctx) => {
+		activity.phase = "tool";
+		activity.activeTools.set(event.toolCallId, describeToolCall(event.toolName, event.args));
+		syncActivitySegment();
+	});
+	pi.on("tool_execution_end", async (event, ctx) => {
+		activity.activeTools.delete(event.toolCallId);
+		activity.phase = activity.activeTools.size > 0 ? "tool" : "thinking";
+		syncActivitySegment();
+		if (editor) updateStatsLabels(editor, pi, ctx, statsCacheBranchLen);
+	});
+	pi.on("message_start", async (event, _ctx) => {
+		if (event.message.role === "assistant") {
+			activity.phase = activity.activeTools.size > 0 ? "tool" : "streaming";
+			syncActivitySegment();
+		}
+	});
+	pi.on("agent_end", async (_event, ctx) => {
+		stopSpinner();
+		activity.phase = "idle";
+		activity.activeTools.clear();
+		statusRow?.remove(ACTIVITY_SEGMENT);
+		if (editor) updateStatsLabels(editor, pi, ctx, statsCacheBranchLen);
+		updateGitSegment(await getGitDiffStats(ctx.cwd));
+	});
+	pi.events.on("editor:set-label", (data) => {
+		const payload = data;
+		if (!payload.key || !payload.text) return;
+		editor?.setLabel(payload.key, payload.text, payload.position ?? "top", payload.align ?? "left");
+	});
+	pi.events.on("editor:remove-label", (data) => {
+		const payload = data;
+		if (!payload.key) return;
+		editor?.removeLabel(payload.key);
+	});
+	pi.on("model_select", async (_event, ctx) => {
+		statsCacheBranchLen.value = -1;
+		if (editor) updateStatsLabels(editor, pi, ctx, statsCacheBranchLen);
+	});
+	pi.on("session_switch", async (_event, ctx) => {
+		branchUnsub?.();
+		branchUnsub = null;
+		gitBranch = null;
+		stopSpinner();
+		activity.phase = "idle";
+		activity.activeTools.clear();
+		statusRow?.clear();
+		statsCacheBranchLen.value = -1;
+		if (editor) updateStatsLabels(editor, pi, ctx, statsCacheBranchLen);
+	});
+}
+//#endregion
+export { editor_default as t };

package/dist/extensions/bash.d.ts

@@ -0,0 +1,12 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/bash/index.d.ts
+type BashExtConfig = {
+  headLines: number;
+  tailLines: number;
+  sigkillDelayMs: number;
+};
+declare function createBashTool(config?: BashExtConfig): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { createBashTool, export_default as default };