@vitos-pizza/vitos-pizza 0.1.0

package/node_modules/@vitos-pizza/ui-enhancements/src/chrome/format-border.ts

@@ -0,0 +1,46 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+export function fitBorder(
+	left: string,
+	right: string,
+	width: number,
+	border: (text: string) => string,
+	fill: (text: string) => string = border,
+): string {
+	if (width <= 0) return "";
+	if (width === 1) return border("─");
+
+	let leftText = left;
+	let rightText = right;
+	const fixedWidth = 2;
+	const minimumGap = 3;
+
+	while (
+		fixedWidth + visibleWidth(leftText) + visibleWidth(rightText) + minimumGap >
+			width &&
+		visibleWidth(rightText) > 0
+	) {
+		rightText = truncateToWidth(
+			rightText,
+			Math.max(0, visibleWidth(rightText) - 1),
+			"",
+		);
+	}
+	while (
+		fixedWidth + visibleWidth(leftText) + visibleWidth(rightText) + minimumGap >
+			width &&
+		visibleWidth(leftText) > 0
+	) {
+		leftText = truncateToWidth(
+			leftText,
+			Math.max(0, visibleWidth(leftText) - 1),
+			"",
+		);
+	}
+
+	const gapWidth = Math.max(
+		0,
+		width - fixedWidth - visibleWidth(leftText) - visibleWidth(rightText),
+	);
+	return `${border("─")}${leftText}${fill("─".repeat(gapWidth))}${rightText}${border("─")}`;
+}

package/node_modules/@vitos-pizza/ui-enhancements/src/chrome/header-info.ts

@@ -0,0 +1,66 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { keyHint } from "@earendil-works/pi-coding-agent";
+
+export interface LoadedCounts {
+	extensions: number;
+	skills: number;
+	promptTemplates: number;
+}
+
+export interface ModelDisplay {
+	modelName: string;
+	providerName: string;
+}
+
+const BUILTIN_TOOL_SOURCE = "@earendil-works/pi-coding-agent";
+
+export function getModelDisplay(ctx: ExtensionContext): ModelDisplay {
+	const model = ctx.model;
+	return {
+		modelName: model?.id ?? "no model",
+		providerName: model?.provider ?? "",
+	};
+}
+
+export function getLoadedCounts(pi: ExtensionAPI): LoadedCounts {
+	const commands = pi.getCommands();
+	const skills = commands.filter(
+		(command) => command.source === "skill",
+	).length;
+	const promptTemplates = commands.filter(
+		(command) => command.source === "prompt",
+	).length;
+
+	const extensionSources = new Set<string>();
+	for (const tool of pi.getAllTools()) {
+		const source = tool.sourceInfo?.source;
+		if (!source || source === BUILTIN_TOOL_SOURCE) continue;
+		extensionSources.add(source);
+	}
+
+	return {
+		extensions: extensionSources.size,
+		skills,
+		promptTemplates,
+	};
+}
+
+export function buildWelcomeTips(showExpandHint: boolean): string[] {
+	const tips = [`/ for commands`];
+	if (showExpandHint) {
+		tips.push(keyHint("app.tools.expand", "expand"));
+	}
+	tips.push(keyHint("app.thinking.cycle", "cycle thinking"));
+	return tips;
+}
+
+export function buildLoadedLines(counts: LoadedCounts): string[] {
+	return [
+		`✓ ${counts.extensions} extension${counts.extensions === 1 ? "" : "s"}`,
+		`✓ ${counts.skills} skill${counts.skills === 1 ? "" : "s"}`,
+		`✓ ${counts.promptTemplates} prompt template${counts.promptTemplates === 1 ? "" : "s"}`,
+	];
+}

package/node_modules/@vitos-pizza/ui-enhancements/src/chrome/recent-sessions.ts

@@ -0,0 +1,132 @@
+import {
+	closeSync,
+	existsSync,
+	openSync,
+	readdirSync,
+	readSync,
+	statSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+
+export interface RecentSession {
+	name: string;
+	timeAgo: string;
+}
+
+const SESSION_HEADER_READ_BYTES = 8192;
+
+export function formatTimeAgo(ms: number): string {
+	const seconds = Math.floor(ms / 1000);
+	const minutes = Math.floor(seconds / 60);
+	const hours = Math.floor(minutes / 60);
+	const days = Math.floor(hours / 24);
+
+	if (days > 0) return `${days}d ago`;
+	if (hours > 0) return `${hours}h ago`;
+	if (minutes > 0) return `${minutes}m ago`;
+	return "just now";
+}
+
+function readSessionHeaderProjectName(filePath: string): string | null {
+	let fd: number | null = null;
+	try {
+		fd = openSync(filePath, "r");
+		const buffer = Buffer.alloc(SESSION_HEADER_READ_BYTES);
+		const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
+		const firstLine = buffer
+			.toString("utf8", 0, bytesRead)
+			.split(/\r?\n/, 1)[0]
+			?.trim();
+		if (!firstLine) return null;
+
+		const header: unknown = JSON.parse(firstLine);
+		if (
+			typeof header !== "object" ||
+			header === null ||
+			Array.isArray(header)
+		) {
+			return null;
+		}
+
+		const cwd = Reflect.get(header, "cwd");
+		if (typeof cwd !== "string" || cwd.trim().length === 0) return null;
+
+		return basename(cwd) || cwd;
+	} catch {
+		return null;
+	} finally {
+		if (fd !== null) closeSync(fd);
+	}
+}
+
+function sessionProjectNameFromDirectory(dir: string): string {
+	const parentName = basename(dir);
+	if (!parentName.startsWith("--")) {
+		return parentName;
+	}
+
+	const parts = parentName.split("-").filter((part) => part);
+	return parts[parts.length - 1] || parentName;
+}
+
+function getAgentSessionDirs(): string[] {
+	return [join(homedir(), ".pi", "agent", "sessions")];
+}
+
+function scanSessionsDir(
+	dir: string,
+	sessions: { name: string; mtime: number }[],
+): void {
+	if (!existsSync(dir)) return;
+
+	try {
+		const entries = readdirSync(dir);
+		for (const entry of entries) {
+			const entryPath = join(dir, entry);
+			try {
+				const stats = statSync(entryPath);
+				if (stats.isDirectory()) {
+					scanSessionsDir(entryPath, sessions);
+				} else if (entry.endsWith(".jsonl")) {
+					const projectName =
+						readSessionHeaderProjectName(entryPath) ??
+						sessionProjectNameFromDirectory(dir);
+					sessions.push({ name: projectName, mtime: stats.mtimeMs });
+				}
+			} catch {
+				// Skip unreadable entries.
+			}
+		}
+	} catch {
+		// Skip unreadable directories.
+	}
+}
+
+export function getRecentSessions(maxCount = 5): RecentSession[] {
+	const sessions: { name: string; mtime: number }[] = [];
+
+	for (const sessionsDir of getAgentSessionDirs()) {
+		scanSessionsDir(sessionsDir, sessions);
+	}
+
+	if (sessions.length === 0) return [];
+
+	sessions.sort((a, b) => b.mtime - a.mtime);
+
+	const seen = new Set<string>();
+	const uniqueSessions: typeof sessions = [];
+	for (const session of sessions) {
+		if (!seen.has(session.name)) {
+			seen.add(session.name);
+			uniqueSessions.push(session);
+		}
+	}
+
+	const now = Date.now();
+	return uniqueSessions.slice(0, maxCount).map((session) => ({
+		name:
+			session.name.length > 20 ? `${session.name.slice(0, 17)}…` : session.name,
+		timeAgo: formatTimeAgo(now - session.mtime),
+	}));
+}

package/node_modules/@vitos-pizza/ui-enhancements/src/chrome/welcome-header.ts

@@ -0,0 +1,127 @@
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { loadUiEnhancementsSettings } from "../config.ts";
+import {
+	buildLoadedLines,
+	buildWelcomeTips,
+	getLoadedCounts,
+	getModelDisplay,
+} from "./header-info.ts";
+
+interface WelcomeHeaderData {
+	modelName: string;
+	providerName: string;
+	tips: string[];
+	loadedLines: string[];
+}
+
+function padLine(text: string, width: number): string {
+	const vis = visibleWidth(text);
+	if (vis >= width) return truncateToWidth(text, width, "…");
+	return text + " ".repeat(width - vis);
+}
+
+function renderStacked(
+	data: WelcomeHeaderData,
+	theme: Theme,
+	width: number,
+): string[] {
+	const lines: string[] = [""];
+	lines.push(theme.fg("accent", " π"));
+	lines.push(theme.fg("muted", " Vito's"));
+	lines.push("");
+	lines.push(theme.fg("success", "Welcome back!"));
+	lines.push(
+		theme.fg("accent", data.modelName) +
+			(data.providerName ? theme.fg("muted", ` · ${data.providerName}`) : ""),
+	);
+	lines.push("");
+	lines.push(theme.fg("accent", theme.bold("Tips")));
+	for (const tip of data.tips) {
+		lines.push(theme.fg("muted", `  ${tip}`));
+	}
+	lines.push("");
+	lines.push(theme.fg("accent", theme.bold("Loaded")));
+	for (const line of data.loadedLines) {
+		lines.push(theme.fg("success", `  ${line}`));
+	}
+	lines.push("");
+	return lines.map((line) => truncateToWidth(line, width, "…"));
+}
+
+function renderTwoColumn(
+	data: WelcomeHeaderData,
+	theme: Theme,
+	width: number,
+): string[] {
+	const leftWidth = Math.min(22, Math.floor(width * 0.35));
+	const rightWidth = Math.max(1, width - leftWidth - 1);
+	const gap = " ";
+
+	const leftRows: string[] = [
+		theme.fg("accent", " π"),
+		theme.fg("muted", " Vito's"),
+		"",
+		theme.fg("accent", theme.bold("Tips")),
+		...data.tips.map((tip) => theme.fg("muted", ` ${tip}`)),
+	];
+
+	const rightRows: string[] = [
+		theme.fg("success", "Welcome back!"),
+		theme.fg("accent", data.modelName) +
+			(data.providerName ? theme.fg("muted", ` · ${data.providerName}`) : ""),
+		"",
+		theme.fg("accent", theme.bold("Loaded")),
+		...data.loadedLines.map((line) => theme.fg("success", ` ${line}`)),
+	];
+
+	const rowCount = Math.max(leftRows.length, rightRows.length);
+	const lines: string[] = [""];
+	for (let i = 0; i < rowCount; i++) {
+		const left = padLine(leftRows[i] ?? "", leftWidth);
+		const right = truncateToWidth(rightRows[i] ?? "", rightWidth, "…");
+		lines.push(left + gap + right);
+	}
+	lines.push("");
+	return lines;
+}
+
+export function registerWelcomeHeader(pi: ExtensionAPI): void {
+	pi.on("session_start", async (_event, ctx) => {
+		const settings = loadUiEnhancementsSettings(ctx.cwd);
+		if (!settings.welcomeHeader || !ctx.hasUI || ctx.mode !== "tui") return;
+
+		const model = getModelDisplay(ctx);
+		const data: WelcomeHeaderData = {
+			modelName: model.modelName,
+			providerName: model.providerName,
+			tips: buildWelcomeTips(settings.showExpandHint),
+			loadedLines: buildLoadedLines(getLoadedCounts(pi)),
+		};
+
+		ctx.ui.setHeader((_tui, theme) => ({
+			invalidate() {},
+			render(width: number): string[] {
+				if (width < 44) {
+					return renderStacked(data, theme, width);
+				}
+				return renderTwoColumn(data, theme, width);
+			},
+		}));
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		if (!ctx.hasUI || ctx.mode !== "tui") return;
+		const settings = loadUiEnhancementsSettings(ctx.cwd);
+		if (!settings.welcomeHeader) return;
+		ctx.ui.setHeader(undefined);
+	});
+
+	pi.registerCommand("builtin-header", {
+		description: "Restore Pi built-in header with keybinding hints",
+		handler: async (_args, ctx) => {
+			ctx.ui.setHeader(undefined);
+			ctx.ui.notify("Built-in header restored", "info");
+		},
+	});
+}

package/node_modules/@vitos-pizza/ui-enhancements/src/config.ts

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export interface UiEnhancementsSettings {
+	toolsCollapsedByDefault: boolean;
+	showExpandHint: boolean;
+	welcomeHeader: boolean;
+	borderStatusBar: boolean;
+}
+
+export const DEFAULT_UI_ENHANCEMENTS_SETTINGS: UiEnhancementsSettings = {
+	toolsCollapsedByDefault: true,
+	showExpandHint: true,
+	welcomeHeader: true,
+	borderStatusBar: true,
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function readJson(path: string): unknown {
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return undefined;
+	}
+}
+
+function extractUiSettings(
+	raw: unknown,
+): Partial<UiEnhancementsSettings> | undefined {
+	if (!isRecord(raw)) return undefined;
+	const ui = raw.ui;
+	if (!isRecord(ui)) return undefined;
+	return ui as Partial<UiEnhancementsSettings>;
+}
+
+function mergeSettings(
+	base: UiEnhancementsSettings,
+	partial?: Partial<UiEnhancementsSettings>,
+): UiEnhancementsSettings {
+	if (!partial) return base;
+	return {
+		toolsCollapsedByDefault:
+			partial.toolsCollapsedByDefault ?? base.toolsCollapsedByDefault,
+		showExpandHint: partial.showExpandHint ?? base.showExpandHint,
+		welcomeHeader: partial.welcomeHeader ?? base.welcomeHeader,
+		borderStatusBar: partial.borderStatusBar ?? base.borderStatusBar,
+	};
+}
+
+export function loadUiEnhancementsSettings(
+	cwd: string,
+	overrides?: Partial<UiEnhancementsSettings>,
+): UiEnhancementsSettings {
+	let merged = { ...DEFAULT_UI_ENHANCEMENTS_SETTINGS };
+
+	const globalPath = join(homedir(), ".pi", "agent", "settings.json");
+	if (existsSync(globalPath)) {
+		merged = mergeSettings(merged, extractUiSettings(readJson(globalPath)));
+	}
+
+	const projectPath = join(cwd, ".pi", "settings.json");
+	if (existsSync(projectPath)) {
+		merged = mergeSettings(merged, extractUiSettings(readJson(projectPath)));
+	}
+
+	if (overrides) {
+		merged = mergeSettings(merged, overrides);
+	}
+
+	return merged;
+}

package/node_modules/@vitos-pizza/ui-enhancements/src/register-ui-enhancements.ts

@@ -0,0 +1,47 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerBorderStatusBar } from "./chrome/border-status.ts";
+import { registerWelcomeHeader } from "./chrome/welcome-header.ts";
+import {
+	DEFAULT_UI_ENHANCEMENTS_SETTINGS,
+	type UiEnhancementsSettings,
+} from "./config.ts";
+import type { UiEnhancementsState } from "./session.ts";
+import {
+	formatUiEnhancementsStatus,
+	registerUiEnhancementsSession,
+} from "./session.ts";
+import { registerCompactBuiltInTools } from "./tools/index.ts";
+
+export interface UiEnhancementsHarness {
+	getState: () => UiEnhancementsState | null;
+}
+
+export function registerUiEnhancements(
+	pi: ExtensionAPI,
+): UiEnhancementsHarness {
+	let state: UiEnhancementsState | null = null;
+	let currentSettings: UiEnhancementsSettings = {
+		...DEFAULT_UI_ENHANCEMENTS_SETTINGS,
+	};
+
+	const getSettings = (): UiEnhancementsSettings => currentSettings;
+
+	registerCompactBuiltInTools(pi);
+	registerWelcomeHeader(pi);
+	registerBorderStatusBar(pi, getSettings);
+	registerUiEnhancementsSession(pi, (next) => {
+		state = next;
+		currentSettings = next.settings;
+	});
+
+	pi.registerCommand("vitos-ui", {
+		description: "Show vitos-pizza UI enhancement settings and status",
+		handler: async (_args, ctx) => {
+			ctx.ui.notify(formatUiEnhancementsStatus(state, ctx), "info");
+		},
+	});
+
+	return {
+		getState: () => state,
+	};
+}

package/node_modules/@vitos-pizza/ui-enhancements/src/session.ts

@@ -0,0 +1,72 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+	loadUiEnhancementsSettings,
+	type UiEnhancementsSettings,
+} from "./config.ts";
+
+export const UI_ENHANCEMENTS_STATUS_KEY = "ui-enhancements";
+
+export interface UiEnhancementsState {
+	settings: UiEnhancementsSettings;
+}
+
+export function registerUiEnhancementsSession(
+	pi: ExtensionAPI,
+	setState: (state: UiEnhancementsState) => void,
+): void {
+	pi.on("session_start", async (_event, ctx) => {
+		const settings = loadUiEnhancementsSettings(ctx.cwd);
+		setState({ settings });
+
+		if (!ctx.hasUI || ctx.mode !== "tui") return;
+
+		if (settings.toolsCollapsedByDefault) {
+			ctx.ui.setToolsExpanded(false);
+		}
+
+		if (settings.showExpandHint && !settings.borderStatusBar) {
+			ctx.ui.setStatus(UI_ENHANCEMENTS_STATUS_KEY, "[ctrl+o: expand]");
+		}
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		ctx.ui.setStatus(UI_ENHANCEMENTS_STATUS_KEY, undefined);
+	});
+}
+
+export function formatUiEnhancementsStatus(
+	state: UiEnhancementsState | null,
+	ctx?: ExtensionContext,
+): string {
+	if (!state) {
+		return "UI enhancements: not initialized";
+	}
+
+	const lines = [
+		"**UI enhancements** (`@vitos-pizza/ui-enhancements`)",
+		"",
+		"| Setting | Value |",
+		"| --- | --- |",
+		`| toolsCollapsedByDefault | \`${state.settings.toolsCollapsedByDefault}\` |`,
+		`| showExpandHint | \`${state.settings.showExpandHint}\` |`,
+		`| welcomeHeader | \`${state.settings.welcomeHeader}\` |`,
+		`| borderStatusBar | \`${state.settings.borderStatusBar}\` |`,
+		"",
+		"**Compact built-in tools:** read, bash, write, edit, find, grep, ls",
+		"",
+		"- Read-only bash: collapsed by default with line count summary",
+		"- write / edit / dangerous bash: always full output",
+		"- Use `ctrl+o` (`app.tools.expand`) to toggle tool output expansion",
+		"",
+		"**Chrome UI:** Vito's welcome header + border status bar (model, thinking, context, cwd, git)",
+	];
+
+	if (ctx?.hasUI && ctx.mode === "tui") {
+		lines.push("", `Current tools expanded: \`${ctx.ui.getToolsExpanded()}\``);
+	}
+
+	return lines.join("\n");
+}