osdy-pi 0.1.3 → 0.1.5

package/extensions/osdy-pi/metrics.ts

@@ -0,0 +1,210 @@
+import {
+	type ExtensionAPI,
+	type ExtensionContext,
+	VERSION,
+} from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { formatPath, shortNumber, truncateMiddle } from "./format.js";
+import type {
+	AssistantSessionEntry,
+	HeaderMetaRow,
+	OsdyState,
+	SimpleTheme,
+} from "./types.js";
+import { centerVisible, fitCenterVisible } from "./utils.js";
+
+function isAssistantSessionEntry(
+	entry: unknown,
+): entry is AssistantSessionEntry {
+	if (!entry || typeof entry !== "object") return false;
+	const candidate = entry as { type?: unknown; message?: unknown };
+	if (candidate.type !== "message") return false;
+	if (!candidate.message || typeof candidate.message !== "object") return false;
+	const message = candidate.message as { role?: unknown };
+	return message.role === "assistant";
+}
+
+export function modelLabel(ctx: ExtensionContext): string {
+	const model = ctx.model;
+	if (!model) return "no model";
+	return model.provider ? `${model.provider}/${model.id}` : model.id;
+}
+
+function getContextLabel(ctx: ExtensionContext): string {
+	const context = ctx.getContextUsage();
+	const contextWindow = context?.contextWindow ?? ctx.model?.contextWindow;
+	const percent = context?.percent ?? null;
+	return contextWindow
+		? `ctx ${percent === null ? "?" : Math.round(percent)}%/${shortNumber(contextWindow)}`
+		: "ctx ?";
+}
+
+function getCacheLabel(totals: UsageTotals): string {
+	return totals.cacheRead || totals.cacheWrite
+		? ` R${shortNumber(totals.cacheRead)} W${shortNumber(totals.cacheWrite)}`
+		: "";
+}
+
+export function usageLabel(ctx: ExtensionContext): string {
+	const totals = collectUsageTotals(ctx);
+	const cacheText = getCacheLabel(totals);
+	const ctxText = getContextLabel(ctx);
+	return ` tok ↑${shortNumber(totals.input)} ↓${shortNumber(totals.output)}${cacheText} · $${totals.cost.toFixed(4)} · ${ctxText} `;
+}
+
+type UsageTotals = {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	cost: number;
+};
+
+function createUsageTotals(): UsageTotals {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		cost: 0,
+	};
+}
+
+function mergeUsageTotals(
+	totals: UsageTotals,
+	entry: AssistantSessionEntry,
+): UsageTotals {
+	const usage = entry.message?.usage;
+	if (!usage) return totals;
+	return {
+		input: totals.input + (usage.input ?? 0),
+		output: totals.output + (usage.output ?? 0),
+		cacheRead: totals.cacheRead + (usage.cacheRead ?? 0),
+		cacheWrite: totals.cacheWrite + (usage.cacheWrite ?? 0),
+		cost: totals.cost + (usage.cost?.total ?? 0),
+	};
+}
+
+function collectUsageTotals(ctx: ExtensionContext): UsageTotals {
+	return ctx.sessionManager
+		.getEntries()
+		.reduce<UsageTotals>((totals, entry) => {
+			return isAssistantSessionEntry(entry)
+				? mergeUsageTotals(totals, entry)
+				: totals;
+		}, createUsageTotals());
+}
+
+function getToolSources(pi: ExtensionAPI) {
+	return pi.getAllTools().map((tool) => ({
+		name: tool.name.toLowerCase(),
+		origin: tool.sourceInfo?.origin?.toLowerCase() ?? "",
+		source: tool.sourceInfo?.source?.toLowerCase() ?? "",
+		path: tool.sourceInfo?.path?.toLowerCase() ?? "",
+	}));
+}
+
+function isMcpTool(tool: ReturnType<typeof getToolSources>[number]): boolean {
+	return tool.name.includes("mcp") || tool.source.includes("mcp");
+}
+
+function getToolServerKey(
+	tool: ReturnType<typeof getToolSources>[number],
+): string {
+	return tool.source || tool.path || tool.name;
+}
+
+function getMcpServerCount(pi: ExtensionAPI): number {
+	const serverKeys = new Set(
+		getToolSources(pi).filter(isMcpTool).map(getToolServerKey),
+	);
+	return serverKeys.size;
+}
+
+function countToolsByOrigin(pi: ExtensionAPI, origin: string): number {
+	return getToolSources(pi).filter((tool) => tool.origin === origin).length;
+}
+
+function countToolsBySource(pi: ExtensionAPI, source: string): number {
+	return getToolSources(pi).filter((tool) => tool.source.includes(source))
+		.length;
+}
+
+function getPathWidth(width: number): number {
+	return width < 110 ? 34 : 52;
+}
+
+export function renderHeaderMetadata(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	width: number,
+): HeaderMetaRow[] {
+	const allTools = pi.getAllTools().length;
+	const git = state.gitLabel === "no-git" ? "Not a git repo" : state.gitLabel;
+	const path = truncateMiddle(formatPath(ctx.cwd), getPathWidth(width));
+	const mcpServerCount = getMcpServerCount(pi);
+	const pluginCount = countToolsByOrigin(pi, "package");
+	const extensionCount = countToolsBySource(pi, "extension");
+	return [
+		{
+			leftLabel: "GIT:",
+			leftValue: git,
+			rightLabel: "PATH:",
+			rightValue: path,
+		},
+		{
+			leftLabel: "MCP:",
+			leftValue: `${mcpServerCount} servers`,
+			rightLabel: "PLUGINS:",
+			rightValue: `${pluginCount} package`,
+		},
+		{
+			leftLabel: "AGENTS:",
+			leftValue: `${state.agentsLabel} loaded`,
+			rightLabel: "EXTENSIONS:",
+			rightValue: `${extensionCount} active`,
+		},
+		{
+			leftLabel: "VER:",
+			leftValue: VERSION,
+			rightLabel: "TOOLS:",
+			rightValue: `${allTools} customs`,
+		},
+	];
+}
+
+export function renderMetaRows(
+	rows: HeaderMetaRow[],
+	width: number,
+	theme: SimpleTheme,
+): string[] {
+	const labelWidth = 11;
+	const leftValueWidth = 32;
+	const rightValueWidth = 52;
+	const gapWidth = 10;
+	const blockWidth =
+		labelWidth +
+		1 +
+		leftValueWidth +
+		gapWidth +
+		labelWidth +
+		1 +
+		rightValueWidth;
+	return rows.map((row) => {
+		const leftLabel = theme.fg("mdLink", row.leftLabel.padEnd(labelWidth));
+		const leftValue = theme.fg(
+			"accent",
+			truncateToWidth(row.leftValue, leftValueWidth).padEnd(leftValueWidth),
+		);
+		const rightLabel = theme.fg("mdLink", row.rightLabel.padEnd(labelWidth));
+		const rightValue = theme.fg(
+			"accent",
+			truncateToWidth(row.rightValue, rightValueWidth).padEnd(rightValueWidth),
+		);
+		const rowText = `${leftLabel} ${leftValue}${" ".repeat(gapWidth)}${rightLabel} ${rightValue}`;
+		return width >= blockWidth
+			? centerVisible(rowText, width)
+			: fitCenterVisible(rowText, width);
+	});
+}

package/extensions/osdy-pi/runtime-helpers.ts

@@ -0,0 +1,101 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { asciiAnimationMode } from "./animation.js";
+import { THEME_NAME, WORKING_WIDGET_KEY } from "./constants.js";
+import { modelLabel, usageLabel } from "./metrics.js";
+import type { OsdyState, WorkingWidgetState } from "./types.js";
+import {
+	createEditorComponent,
+	createFooterComponent,
+	createHeaderComponent,
+	createWorkingWidgetFactory,
+} from "./ui.js";
+
+function shouldRememberTheme(
+	previousThemeName: string | undefined,
+	currentTheme: string | undefined,
+): currentTheme is string {
+	return (
+		previousThemeName === undefined &&
+		currentTheme !== undefined &&
+		currentTheme !== THEME_NAME
+	);
+}
+
+export function rememberPreviousTheme(
+	ctx: ExtensionContext,
+	state: OsdyState,
+): void {
+	const currentTheme = ctx.ui.theme.name;
+	if (shouldRememberTheme(state.previousThemeName, currentTheme)) {
+		state.previousThemeName = currentTheme;
+	}
+}
+
+export function applyOsdyTheme(ctx: ExtensionContext): void {
+	const osdyTheme = ctx.ui.getTheme(THEME_NAME);
+	const themeResult = osdyTheme
+		? ctx.ui.setTheme(osdyTheme)
+		: ctx.ui.setTheme(THEME_NAME);
+	if (!themeResult.success) {
+		ctx.ui.notify(
+			`osdy-pi theme failed: ${themeResult.error ?? "unknown error"}`,
+			"warning",
+		);
+	}
+}
+
+export function mountOsdyUi(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+): void {
+	ctx.ui.setHeader(createHeaderComponent(pi, ctx, state));
+	ctx.ui.setFooter((_tui, theme, footerData) =>
+		createFooterComponent(ctx, footerData, theme),
+	);
+	ctx.ui.setWorkingVisible(false);
+	ctx.ui.setWidget(
+		WORKING_WIDGET_KEY,
+		createWorkingWidgetFactory(workingState),
+		{ placement: "aboveEditor" },
+	);
+	ctx.ui.setEditorComponent(createEditorComponent(pi, ctx));
+}
+
+export function applyOsdyPi(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+	notify = false,
+): void {
+	if (!ctx.hasUI) return;
+	rememberPreviousTheme(ctx, state);
+	applyOsdyTheme(ctx);
+	mountOsdyUi(pi, ctx, state, workingState);
+	if (notify) ctx.ui.notify("osdy-pi enabled", "info");
+}
+
+export function disableOsdyPi(ctx: ExtensionContext, state: OsdyState): void {
+	if (!ctx.hasUI) return;
+	ctx.ui.setHeader(undefined);
+	ctx.ui.setEditorComponent(undefined);
+	ctx.ui.setFooter(undefined);
+	ctx.ui.setWidget(WORKING_WIDGET_KEY, undefined);
+	ctx.ui.setWorkingVisible(true);
+	const targetTheme = state.previousThemeName ?? "dark";
+	const result = ctx.ui.setTheme(targetTheme);
+	if (!result.success && targetTheme !== "dark") ctx.ui.setTheme("dark");
+	ctx.ui.notify("osdy-pi disabled", "info");
+}
+
+export function notifyStatus(ctx: ExtensionContext, state: OsdyState): void {
+	ctx.ui.notify(
+		`osdy-pi ${state.enabled ? "enabled" : "disabled"} · theme ${ctx.ui.theme.name ?? "unknown"} · style ${state.headerVariant} · animation ${asciiAnimationMode()} · ${modelLabel(ctx)} · ${usageLabel(ctx).trim()}`,
+		"info",
+	);
+}

package/extensions/osdy-pi/runtime.ts

@@ -0,0 +1,194 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { applyOsdyPi, disableOsdyPi, notifyStatus } from "./runtime-helpers.js";
+import type { HeaderVariant, 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 parseCommandArgs(args: string): string[] {
+	return args.trim().split(/\s+/).filter(Boolean);
+}
+
+const HEADER_VARIANTS = ["osdy-theme", "classic"] as const;
+
+function isHeaderVariant(value: string): value is HeaderVariant {
+	return HEADER_VARIANTS.includes(value as HeaderVariant);
+}
+
+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 setHeaderVariant(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+	variant: HeaderVariant,
+): void {
+	state.headerVariant = variant;
+	if (state.enabled) applyOsdyPi(pi, ctx, state, workingState);
+	ctx.ui.notify(`osdy-pi style: ${variant}`, "info");
+}
+
+function registerCommand(
+	pi: ExtensionAPI,
+	state: OsdyState,
+	workingState: WorkingWidgetState,
+	controller: WorkingController,
+): void {
+	pi.registerCommand("osdy-pi", {
+		description:
+			"Manage the Osdy Pi experience: enable, disable, status, or style.",
+		getArgumentCompletions(prefix: string) {
+			const trimmed = prefix.trim();
+			const parts = parseCommandArgs(trimmed);
+			if (parts.length <= 1) {
+				const valuePrefix = parts[0] ?? "";
+				return ["enable", "disable", "status", ...HEADER_VARIANTS]
+					.filter((value) => value.startsWith(valuePrefix))
+					.map((value) => ({ value, label: value }));
+			}
+			return null;
+		},
+		handler: (args, ctx) => {
+			const [action = "status"] = parseCommandArgs(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();
+			}
+			if (isHeaderVariant(action)) {
+				setHeaderVariant(pi, ctx, state, workingState, action);
+				return Promise.resolve();
+			}
+			ctx.ui.notify(
+				"Usage: /osdy-pi enable | disable | status | osdy-theme | classic",
+				"warning",
+			);
+			return Promise.resolve();
+		},
+	});
+
+	for (const variant of HEADER_VARIANTS) {
+		pi.registerCommand(`osdy-pi-${variant}`, {
+			description: `Switch Osdy Pi header to ${variant}.`,
+			handler: (_args, ctx) => {
+				setHeaderVariant(pi, ctx, state, workingState, variant);
+				return Promise.resolve();
+			},
+		});
+	}
+}
+
+export function registerOsdyPi(pi: ExtensionAPI): void {
+	const state: OsdyState = {
+		enabled: true,
+		headerVariant: "osdy-theme",
+		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,53 @@
+import type { TUI } from "@earendil-works/pi-tui";
+
+export type AnimationMode = "off" | "intro" | "continuous";
+
+export type HeaderVariant = "osdy-theme" | "classic";
+
+export type OsdyState = {
+	enabled: boolean;
+	headerVariant: HeaderVariant;
+	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;
+};