osdy-pi 0.1.2 → 0.1.4

package/extensions/osdy-pi/runtime.ts

@@ -0,0 +1,147 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { applyOsdyPi, disableOsdyPi, notifyStatus } from "./runtime-helpers.js";
+import type { OsdyState, WorkingWidgetState } from "./types.js";
+import {
+	createWorkingController,
+	type WorkingController,
+} from "./working-controller.js";
+
+function scheduleOsdyRefresh(
+	delayMs: number,
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+): void {
+	setTimeout(() => {
+		if (state.enabled) applyOsdyPi(pi, ctx, state, workingState);
+	}, delayMs);
+}
+
+function claimOsdyVisualLayer(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+): void {
+	if (!state.enabled) return;
+	applyOsdyPi(pi, ctx, state, workingState);
+	for (const delayMs of [300, 1000]) {
+		scheduleOsdyRefresh(delayMs, pi, ctx, state, workingState);
+	}
+}
+
+function loadSessionMetadata(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+): void {
+	void pi
+		.exec("git", ["branch", "--show-current"], { cwd: ctx.cwd })
+		.then((result) => {
+			state.gitLabel = result.stdout.trim() || "detached";
+		})
+		.catch(() => {
+			state.gitLabel = "no-git";
+		});
+	void pi
+		.exec("find", [ctx.cwd, "-name", "AGENTS.md", "-o", "-name", "AGENTS.MD"], {
+			cwd: ctx.cwd,
+		})
+		.then((result) => {
+			state.agentsLabel = String(
+				result.stdout.split("\n").filter(Boolean).length,
+			);
+		})
+		.catch(() => {
+			state.agentsLabel = "0";
+		});
+}
+
+function parseCommandAction(args: string): string {
+	return args.trim().split(/\s+/, 1)[0] || "status";
+}
+
+function enableOsdyPi(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+	controller: WorkingController,
+): void {
+	state.enabled = true;
+	applyOsdyPi(pi, ctx, state, workingState, true);
+	controller.refreshWorking();
+}
+
+function disableOsdyPiCommand(
+	ctx: ExtensionContext,
+	state: OsdyState,
+	controller: WorkingController,
+): void {
+	state.enabled = false;
+	controller.stopWorking();
+	disableOsdyPi(ctx, state);
+}
+
+function registerCommand(
+	pi: ExtensionAPI,
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+	controller: WorkingController,
+): void {
+	pi.registerCommand("osdy-pi", {
+		description: "Manage the Osdy Pi experience: enable, disable, or status.",
+		getArgumentCompletions(prefix: string) {
+			return ["enable", "disable", "status"]
+				.filter((value) => value.startsWith(prefix.trim()))
+				.map((value) => ({ value, label: value }));
+		},
+		handler: (args, ctx) => {
+			const action = parseCommandAction(args);
+			if (action === "enable") {
+				enableOsdyPi(pi, ctx, state, workingState, controller);
+				return Promise.resolve();
+			}
+			if (action === "disable") {
+				disableOsdyPiCommand(ctx, state, controller);
+				return Promise.resolve();
+			}
+			if (action === "status") {
+				notifyStatus(ctx, state);
+				return Promise.resolve();
+			}
+			ctx.ui.notify("Usage: /osdy-pi enable | disable | status", "warning");
+			return Promise.resolve();
+		},
+	});
+}
+
+export function registerOsdyPi(pi: ExtensionAPI): void {
+	const state: OsdyState = { enabled: true, gitLabel: "-", agentsLabel: "-" };
+	const workingState: WorkingWidgetState = {
+		active: false,
+		label: "Working...",
+		frame: 0,
+		timer: undefined,
+		tui: undefined,
+	};
+	const controller = createWorkingController(state, workingState);
+
+	pi.on("agent_start", () => controller.onAgentStart());
+	pi.on("agent_end", () => controller.onAgentEnd());
+	pi.on("tool_execution_start", (event) =>
+		controller.onToolStart(event.toolName),
+	);
+	pi.on("tool_execution_end", () => controller.onToolEnd());
+	pi.on("session_shutdown", () => controller.onShutdown());
+	pi.on("session_start", (_event, ctx) => {
+		loadSessionMetadata(pi, ctx, state);
+		claimOsdyVisualLayer(pi, ctx, state, workingState);
+	});
+
+	registerCommand(pi, state, workingState, controller);
+}

package/extensions/osdy-pi/types.ts

@@ -0,0 +1,50 @@
+import type { TUI } from "@earendil-works/pi-tui";
+
+export type AnimationMode = "off" | "intro" | "continuous";
+
+export type OsdyState = {
+	enabled: boolean;
+	previousThemeName?: string;
+	gitLabel: string;
+	agentsLabel: string;
+};
+
+export type WorkingWidgetState = {
+	active: boolean;
+	label: string;
+	frame: number;
+	timer: ReturnType<typeof setInterval> | undefined;
+	tui: TUI | undefined;
+};
+
+export type AssistantUsage = {
+	input?: number;
+	output?: number;
+	cacheRead?: number;
+	cacheWrite?: number;
+	cost?: {
+		total?: number;
+	};
+};
+
+export type AssistantSessionEntry = {
+	type: "message";
+	id: string;
+	parentId: string | null;
+	timestamp: string;
+	message?: {
+		role?: string;
+		usage?: AssistantUsage;
+	};
+};
+
+export type HeaderMetaRow = {
+	leftLabel: string;
+	leftValue: string;
+	rightLabel: string;
+	rightValue: string;
+};
+
+export type SimpleTheme = {
+	fg(name: string, text: string): string;
+};

package/extensions/osdy-pi/ui.ts

@@ -0,0 +1,259 @@
+import {
+	CustomEditor,
+	type ExtensionAPI,
+	type ExtensionContext,
+	type KeybindingsManager,
+	type ReadonlyFooterDataProvider,
+} from "@earendil-works/pi-coding-agent";
+import {
+	type Component,
+	type EditorTheme,
+	type TUI,
+	truncateToWidth,
+	visibleWidth,
+} from "@earendil-works/pi-tui";
+import { animateAsciiLine, asciiAnimationMode } from "./animation.js";
+import { fitBorder } from "./border.js";
+import {
+	ANIMATION_INTERVAL_MS,
+	HEADER,
+	HEADER_FALLBACK,
+	HEADER_WIDTH,
+	INTRO_ANIMATION_FRAMES,
+	MASCOT,
+	MASCOT_GAP,
+	MASCOT_MIN_ROWS,
+	MASCOT_WIDTH,
+	WORKING_SPINNER_FRAMES,
+} from "./constants.js";
+import { formatPath } from "./format.js";
+import {
+	modelLabel,
+	renderHeaderMetadata,
+	renderMetaRows,
+	usageLabel,
+} from "./metrics.js";
+import type { OsdyState, SimpleTheme, WorkingWidgetState } from "./types.js";
+import {
+	composeSideBySide,
+	fitCenterVisible,
+	internalLineTarget,
+	sanitizeStatusText,
+} from "./utils.js";
+
+class OsdyFooter implements Component {
+	private readonly ctx: ExtensionContext;
+	private readonly footerData: ReadonlyFooterDataProvider;
+	private readonly theme: SimpleTheme;
+
+	constructor(
+		ctx: ExtensionContext,
+		footerData: ReadonlyFooterDataProvider,
+		theme: SimpleTheme,
+	) {
+		this.ctx = ctx;
+		this.footerData = footerData;
+		this.theme = theme;
+	}
+
+	render(width: number): string[] {
+		let location = formatPath(this.ctx.cwd);
+		const branch = this.footerData.getGitBranch?.();
+		if (branch) location = `${location} (${branch})`;
+		const locationLine = truncateToWidth(
+			this.theme.fg("dim", location),
+			width,
+			this.theme.fg("dim", "..."),
+		);
+		const statuses = this.footerData.getExtensionStatuses?.() ?? new Map();
+		const statusEntries = Array.from(statuses.entries());
+		const statusLine = statusEntries
+			.sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey))
+			.map(([, text]) => sanitizeStatusText(text))
+			.join(" ");
+		return statusLine
+			? [
+					locationLine,
+					truncateToWidth(statusLine, width, this.theme.fg("dim", "...")),
+				]
+			: [locationLine];
+	}
+
+	invalidate(): void {}
+}
+
+class OsdyWorkingWidget implements Component {
+	private readonly state: WorkingWidgetState;
+	private readonly theme: SimpleTheme;
+
+	constructor(state: WorkingWidgetState, theme: SimpleTheme) {
+		this.state = state;
+		this.theme = theme;
+	}
+
+	render(width: number): string[] {
+		if (!this.state.active) return [];
+		const frame =
+			WORKING_SPINNER_FRAMES[
+				this.state.frame % WORKING_SPINNER_FRAMES.length
+			] ??
+			WORKING_SPINNER_FRAMES[0] ??
+			"⠋";
+		const line = `${this.theme.fg("accent", frame)} ${this.theme.fg("muted", this.state.label)}`;
+		return [fitCenterVisible(line, width)];
+	}
+
+	invalidate(): void {}
+}
+
+export function createHeaderComponent(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+) {
+	return (_tui: TUI, theme: SimpleTheme) => {
+		let frame = 0;
+		let animationComplete = false;
+		const animationMode = asciiAnimationMode();
+		const animateAscii = animationMode !== "off";
+		const timer = animateAscii
+			? setInterval(() => {
+					frame += 1;
+					if (animationMode === "intro" && frame >= INTRO_ANIMATION_FRAMES) {
+						animationComplete = true;
+						clearInterval(timer);
+					}
+					_tui.requestRender();
+				}, ANIMATION_INTERVAL_MS)
+			: undefined;
+		return {
+			render(width: number): string[] {
+				const animationStyle =
+					animateAscii && !animationComplete ? "animated" : "static";
+				const showMascot =
+					_tui.terminal.rows >= MASCOT_MIN_ROWS &&
+					width >= MASCOT_WIDTH + MASCOT_GAP + HEADER_WIDTH;
+				const useFullHeader = width >= HEADER_WIDTH;
+				const headerLines = useFullHeader ? [...HEADER] : [...HEADER_FALLBACK];
+				const metadataRows = renderHeaderMetadata(pi, ctx, state, width);
+				const logoLines = headerLines.map((line, index) => {
+					const baseColor = useFullHeader && index >= 6 ? "mdLink" : "accent";
+					return animateAsciiLine(
+						line,
+						index,
+						frame,
+						theme,
+						baseColor,
+						"mdHeading",
+						"mdLink",
+						animationStyle,
+					);
+				});
+				const mascotLines = MASCOT.map((line, index) =>
+					animateAsciiLine(
+						line,
+						index,
+						frame,
+						theme,
+						"muted",
+						"mdCode",
+						"muted",
+						animationStyle,
+					),
+				);
+				const headerBlock = showMascot
+					? composeSideBySide(mascotLines, logoLines, width)
+					: logoLines.map((line) => fitCenterVisible(line, width));
+				return [
+					"",
+					...headerBlock,
+					"",
+					...renderMetaRows(metadataRows, width, theme),
+					"",
+				];
+			},
+			invalidate() {},
+			dispose() {
+				if (timer) clearInterval(timer);
+			},
+		};
+	};
+}
+
+export function createFooterComponent(
+	ctx: ExtensionContext,
+	footerData: ReadonlyFooterDataProvider,
+	theme: SimpleTheme,
+): Component {
+	return new OsdyFooter(ctx, footerData, theme);
+}
+
+export function createWorkingWidgetFactory(workingState: WorkingWidgetState) {
+	return (tui: TUI, theme: SimpleTheme): Component => {
+		workingState.tui = tui;
+		return new OsdyWorkingWidget(workingState, theme);
+	};
+}
+
+export function createEditorComponent(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+): (
+	tui: TUI,
+	theme: EditorTheme,
+	keybindings: KeybindingsManager,
+) => CustomEditor {
+	class OsdyEditor extends CustomEditor {
+		private readonly tuiRef: TUI;
+
+		constructor(
+			tuiRef: TUI,
+			theme: EditorTheme,
+			keybindings: KeybindingsManager,
+		) {
+			super(tuiRef, theme, keybindings, { paddingX: 1 });
+			this.tuiRef = tuiRef;
+		}
+
+		override render(width: number): string[] {
+			if (width < 4 || this.isShowingAutocomplete()) return super.render(width);
+			const editorWidth = width;
+			const innerWidth = Math.max(1, editorWidth - 2);
+			const lines = super.render(innerWidth);
+			if (lines.length < 2) return lines;
+			let bottomIndex = Math.max(1, lines.length - 1);
+			const target = internalLineTarget(this.tuiRef);
+			const internalLines = bottomIndex - 1;
+			if (internalLines < target) {
+				const blank = " ".repeat(innerWidth);
+				const added = Array.from(
+					{ length: target - internalLines },
+					() => blank,
+				);
+				lines.splice(bottomIndex, 0, ...added);
+				bottomIndex += added.length;
+			}
+			const borderColor = (text: string) => this.borderColor(text);
+			const side = borderColor("│");
+			for (let index = 1; index < bottomIndex; index += 1) {
+				const content = truncateToWidth(lines[index] ?? "", innerWidth, "");
+				const padding = " ".repeat(
+					Math.max(0, innerWidth - visibleWidth(content)),
+				);
+				lines[index] = `${side}${content}${padding}${side}`;
+			}
+			const topLeft = ctx.ui.theme.fg("mdLink", " Osdy-Pi ");
+			const topRight = ctx.ui.theme.fg(
+				"muted",
+				` ${modelLabel(ctx)} · think ${pi.getThinkingLevel()} `,
+			);
+			const bottomLeft = ctx.ui.theme.fg("muted", usageLabel(ctx));
+			lines[0] = `${borderColor("╭")}${fitBorder(topLeft, topRight, editorWidth - 2, borderColor)}${borderColor("╮")}`;
+			lines[bottomIndex] =
+				`${borderColor("╰")}${fitBorder(bottomLeft, "", editorWidth - 2, borderColor)}${borderColor("╯")}`;
+			return lines;
+		}
+	}
+
+	return (tui, theme, keybindings) => new OsdyEditor(tui, theme, keybindings);
+}

package/extensions/osdy-pi/utils.ts

@@ -0,0 +1,54 @@
+import type { TUI } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { HEADER_WIDTH, MASCOT_GAP, MASCOT_WIDTH } from "./constants.js";
+
+export function sanitizeStatusText(text: string): string {
+	return text
+		.replace(/[\r\n\t]/g, " ")
+		.replace(/ +/g, " ")
+		.trim();
+}
+
+export function positiveModulo(value: number, divisor: number): number {
+	return ((value % divisor) + divisor) % divisor;
+}
+
+export function centerVisible(line: string, width: number): string {
+	const leftPad = Math.max(0, Math.floor((width - visibleWidth(line)) / 2));
+	return `${" ".repeat(leftPad)}${line}`;
+}
+
+export function fitCenterVisible(line: string, width: number): string {
+	return centerVisible(truncateToWidth(line, Math.max(1, width)), width);
+}
+
+export function padVisibleRight(line: string, width: number): string {
+	return `${line}${" ".repeat(Math.max(0, width - visibleWidth(line)))}`;
+}
+
+function getCombinedHeaderWidth(): number {
+	return MASCOT_WIDTH + MASCOT_GAP + HEADER_WIDTH;
+}
+
+export function composeSideBySide(
+	leftLines: string[],
+	rightLines: string[],
+	width: number,
+): string[] {
+	const combinedWidth = getCombinedHeaderWidth();
+	if (width < combinedWidth) return rightLines;
+	const leftPad = " ".repeat(
+		Math.max(0, Math.floor((width - combinedWidth) / 2)),
+	);
+	const rows = Math.max(leftLines.length, rightLines.length);
+	const topOffset = Math.max(0, Math.floor((rows - rightLines.length) / 2));
+	return Array.from({ length: rows }, (_, index) => {
+		const left = padVisibleRight(leftLines[index] ?? "", MASCOT_WIDTH);
+		const right = rightLines[index - topOffset] ?? "";
+		return `${leftPad}${left}${" ".repeat(MASCOT_GAP)}${right}`;
+	});
+}
+
+export function internalLineTarget(tui: TUI): number {
+	return tui.terminal.rows < 18 ? 3 : 4;
+}

package/extensions/osdy-pi/working-controller.ts

@@ -0,0 +1,87 @@
+import type { OsdyState, WorkingWidgetState } from "./types.js";
+
+export type WorkingController = {
+	onAgentStart(): void;
+	onAgentEnd(): void;
+	onToolStart(toolName: string): void;
+	onToolEnd(): void;
+	onShutdown(): void;
+	refreshWorking(): void;
+	stopWorking(): void;
+};
+
+export function createWorkingController(
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+): WorkingController {
+	let activeAgent = false;
+	let activeToolCount = 0;
+
+	const requestWorkingRender = () => workingState.tui?.requestRender();
+	const clearWorkingTimer = () => {
+		if (!workingState.timer) return;
+		clearInterval(workingState.timer);
+		workingState.timer = undefined;
+	};
+	const ensureWorkingTimer = () => {
+		if (workingState.timer) return;
+		workingState.timer = setInterval(() => {
+			workingState.frame += 1;
+			requestWorkingRender();
+		}, 80);
+	};
+	const setWorkingState = (active: boolean, label: string) => {
+		workingState.active = active;
+		workingState.label = label;
+	};
+	const startWorking = (label: string) => {
+		if (!state.enabled) return;
+		setWorkingState(true, label);
+		ensureWorkingTimer();
+		requestWorkingRender();
+	};
+	const stopWorking = () => {
+		setWorkingState(false, workingState.label);
+		clearWorkingTimer();
+		requestWorkingRender();
+	};
+	const getIdleLabel = () =>
+		activeToolCount > 0 ? "Running tool..." : "Working...";
+	const refreshWorking = () => {
+		if (!state.enabled || (!activeAgent && activeToolCount === 0)) {
+			stopWorking();
+			return;
+		}
+		startWorking(getIdleLabel());
+	};
+	const resetActivity = () => {
+		activeAgent = false;
+		activeToolCount = 0;
+	};
+
+	return {
+		onAgentStart(): void {
+			activeAgent = true;
+			refreshWorking();
+		},
+		onAgentEnd(): void {
+			resetActivity();
+			refreshWorking();
+		},
+		onToolStart(toolName: string): void {
+			activeToolCount += 1;
+			startWorking(`Running ${toolName}...`);
+		},
+		onToolEnd(): void {
+			activeToolCount = Math.max(0, activeToolCount - 1);
+			refreshWorking();
+		},
+		onShutdown(): void {
+			resetActivity();
+			stopWorking();
+			workingState.tui = undefined;
+		},
+		refreshWorking,
+		stopWorking,
+	};
+}