@oh-my-pi/pi-coding-agent 6.9.69 → 7.0.0

package/src/modes/interactive/controllers/command-controller.ts

@@ -1,6 +1,7 @@
 import { mkdir, rm } from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
+import type { UsageLimit, UsageReport } from "@oh-my-pi/pi-ai";
 import { Loader, Markdown, Spacer, Text, visibleWidth } from "@oh-my-pi/pi-tui";
 import { $ } from "bun";
 import { nanoid } from "nanoid";
@@ -284,6 +285,33 @@ export class CommandController {
 		this.ctx.ui.requestRender();
 	}
 
+	async handleUsageCommand(reports?: UsageReport[] | null): Promise<void> {
+		let usageReports = reports ?? null;
+		if (!usageReports) {
+			const provider = this.ctx.session as { fetchUsageReports?: () => Promise<UsageReport[] | null> };
+			if (!provider.fetchUsageReports) {
+				this.ctx.showWarning("Usage reporting is not configured for this session.");
+				return;
+			}
+			try {
+				usageReports = await provider.fetchUsageReports();
+			} catch (error) {
+				this.ctx.showError(`Failed to fetch usage data: ${error instanceof Error ? error.message : String(error)}`);
+				return;
+			}
+		}
+
+		if (!usageReports || usageReports.length === 0) {
+			this.ctx.showWarning("No usage data available.");
+			return;
+		}
+
+		const output = renderUsageReports(usageReports, theme, Date.now());
+		this.ctx.chatContainer.addChild(new Spacer(1));
+		this.ctx.chatContainer.addChild(new Text(output, 1, 0));
+		this.ctx.ui.requestRender();
+	}
+
 	handleChangelogCommand(): void {
 		const changelogPath = getChangelogPath();
 		const allEntries = parseChangelog(changelogPath);
@@ -598,3 +626,324 @@ export class CommandController {
 		await this.ctx.flushCompactionQueue({ willRetry: false });
 	}
 }
+
+const BAR_WIDTH = 24;
+const COLUMN_WIDTH = BAR_WIDTH + 2;
+
+function formatProviderName(provider: string): string {
+	return provider
+		.split(/[-_]/g)
+		.map((part) => (part ? part[0].toUpperCase() + part.slice(1) : ""))
+		.join(" ");
+}
+
+function formatNumber(value: number, maxFractionDigits = 1): string {
+	return new Intl.NumberFormat("en-US", { maximumFractionDigits: maxFractionDigits }).format(value);
+}
+
+function formatUsedAccounts(value: number): string {
+	return `${value.toFixed(2)} used`;
+}
+
+function formatDuration(ms: number): string {
+	const totalSeconds = Math.max(0, Math.round(ms / 1000));
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	const hours = Math.floor(minutes / 60);
+	const mins = minutes % 60;
+	const days = Math.floor(hours / 24);
+	const hrs = hours % 24;
+	if (days > 0) return `${days}d ${hrs}h`;
+	if (hours > 0) return `${hours}h ${mins}m`;
+	if (minutes > 0) return `${minutes}m ${seconds}s`;
+	return `${seconds}s`;
+}
+
+function formatDurationShort(ms: number): string {
+	const totalSeconds = Math.max(0, Math.round(ms / 1000));
+	const minutes = Math.floor(totalSeconds / 60);
+	const hours = Math.floor(minutes / 60);
+	const mins = minutes % 60;
+	const days = Math.floor(hours / 24);
+	const hrs = hours % 24;
+	if (days > 0) return `${days}d${hrs > 0 ? ` ${hrs}h` : ""}`;
+	if (hours > 0) return `${hours}h${mins > 0 ? ` ${mins}m` : ""}`;
+	if (minutes > 0) return `${minutes}m`;
+	return `${totalSeconds}s`;
+}
+
+function resolveFraction(limit: UsageLimit): number | undefined {
+	const amount = limit.amount;
+	if (amount.usedFraction !== undefined) return amount.usedFraction;
+	if (amount.used !== undefined && amount.limit !== undefined && amount.limit > 0) {
+		return amount.used / amount.limit;
+	}
+	if (amount.unit === "percent" && amount.used !== undefined) {
+		return amount.used / 100;
+	}
+	return undefined;
+}
+
+function resolveProviderUsageTotal(reports: UsageReport[]): number {
+	return reports
+		.flatMap((report) => report.limits)
+		.map((limit) => resolveFraction(limit) ?? 0)
+		.reduce((sum, value) => sum + value, 0);
+}
+
+function formatLimitTitle(limit: UsageLimit): string {
+	const tier = limit.scope.tier;
+	if (tier && !limit.label.toLowerCase().includes(tier.toLowerCase())) {
+		return `${limit.label} (${tier})`;
+	}
+	return limit.label;
+}
+
+function formatWindowSuffix(label: string, windowLabel: string, uiTheme: typeof theme): string {
+	const normalizedLabel = label.toLowerCase();
+	const normalizedWindow = windowLabel.toLowerCase();
+	if (normalizedWindow === "quota window") return "";
+	if (normalizedLabel.includes(normalizedWindow)) return "";
+	return uiTheme.fg("dim", `(${windowLabel})`);
+}
+
+function formatAccountLabel(limit: UsageLimit, report: UsageReport, index: number): string {
+	const email = (report.metadata?.email as string | undefined) ?? limit.scope.accountId;
+	if (email) return email;
+	const accountId = (report.metadata?.accountId as string | undefined) ?? limit.scope.accountId;
+	if (accountId) return accountId;
+	return `account ${index + 1}`;
+}
+
+function formatResetShort(limit: UsageLimit, nowMs: number): string | undefined {
+	if (limit.window?.resetInMs !== undefined) {
+		return formatDurationShort(limit.window.resetInMs);
+	}
+	if (limit.window?.resetsAt !== undefined) {
+		return formatDurationShort(limit.window.resetsAt - nowMs);
+	}
+	return undefined;
+}
+
+function formatAccountHeader(limit: UsageLimit, report: UsageReport, index: number, nowMs: number): string {
+	const label = formatAccountLabel(limit, report, index);
+	const reset = formatResetShort(limit, nowMs);
+	if (!reset) return label;
+	return `${label} (${reset})`;
+}
+
+function padColumn(text: string, width: number): string {
+	const visible = visibleWidth(text);
+	if (visible >= width) return text;
+	return `${text}${" ".repeat(width - visible)}`;
+}
+
+function resolveAggregateStatus(limits: UsageLimit[]): UsageLimit["status"] {
+	const hasOk = limits.some((limit) => limit.status === "ok");
+	const hasWarning = limits.some((limit) => limit.status === "warning");
+	const hasExhausted = limits.some((limit) => limit.status === "exhausted");
+	if (!hasOk && !hasWarning && !hasExhausted) return "unknown";
+	if (hasOk) {
+		return hasWarning || hasExhausted ? "warning" : "ok";
+	}
+	if (hasWarning) return "warning";
+	return "exhausted";
+}
+
+function isZeroUsage(limit: UsageLimit): boolean {
+	const amount = limit.amount;
+	if (amount.usedFraction !== undefined) return amount.usedFraction <= 0;
+	if (amount.used !== undefined) return amount.used <= 0;
+	if (amount.unit === "percent" && amount.used !== undefined) return amount.used <= 0;
+	if (amount.remainingFraction !== undefined) return amount.remainingFraction >= 1;
+	return false;
+}
+
+function isZeroUsageGroup(limits: UsageLimit[]): boolean {
+	return limits.length > 0 && limits.every((limit) => isZeroUsage(limit));
+}
+
+function formatAggregateAmount(limits: UsageLimit[]): string {
+	const fractions = limits
+		.map((limit) => resolveFraction(limit))
+		.filter((value): value is number => value !== undefined);
+	if (fractions.length === limits.length && fractions.length > 0) {
+		const sum = fractions.reduce((total, value) => total + value, 0);
+		const usedPct = Math.max(sum * 100, 0);
+		const remainingPct = Math.max(0, limits.length * 100 - usedPct);
+		const avgRemaining = limits.length > 0 ? remainingPct / limits.length : remainingPct;
+		return `${formatUsedAccounts(sum)} (${formatNumber(avgRemaining)}% left)`;
+	}
+
+	const amounts = limits
+		.map((limit) => limit.amount)
+		.filter((amount) => amount.used !== undefined && amount.limit !== undefined && amount.limit > 0);
+	if (amounts.length === limits.length && amounts.length > 0) {
+		const totalUsed = amounts.reduce((sum, amount) => sum + (amount.used ?? 0), 0);
+		const totalLimit = amounts.reduce((sum, amount) => sum + (amount.limit ?? 0), 0);
+		const usedPct = totalLimit > 0 ? (totalUsed / totalLimit) * 100 : 0;
+		const remainingPct = Math.max(0, 100 - usedPct);
+		const usedAccounts = totalLimit > 0 ? (usedPct / 100) * limits.length : 0;
+		return `${formatUsedAccounts(usedAccounts)} (${formatNumber(remainingPct)}% left)`;
+	}
+
+	return `Accounts: ${limits.length}`;
+}
+
+function resolveResetRange(limits: UsageLimit[], nowMs: number): string | null {
+	const resets = limits
+		.map((limit) => limit.window?.resetInMs ?? undefined)
+		.filter((value): value is number => value !== undefined && Number.isFinite(value) && value > 0);
+	if (resets.length === 0) {
+		const absolute = limits
+			.map((limit) => limit.window?.resetsAt)
+			.filter((value): value is number => value !== undefined && Number.isFinite(value) && value > nowMs);
+		if (absolute.length === 0) return null;
+		const earliest = Math.min(...absolute);
+		return `resets at ${new Date(earliest).toLocaleString()}`;
+	}
+	const minReset = Math.min(...resets);
+	const maxReset = Math.max(...resets);
+	if (maxReset - minReset > 60_000) {
+		return `resets in ${formatDuration(minReset)}–${formatDuration(maxReset)}`;
+	}
+	return `resets in ${formatDuration(minReset)}`;
+}
+
+function resolveStatusIcon(status: UsageLimit["status"], uiTheme: typeof theme): string {
+	if (status === "exhausted") return uiTheme.fg("error", uiTheme.status.error);
+	if (status === "warning") return uiTheme.fg("warning", uiTheme.status.warning);
+	if (status === "ok") return uiTheme.fg("success", uiTheme.status.success);
+	return uiTheme.fg("dim", uiTheme.status.pending);
+}
+
+function resolveStatusColor(status: UsageLimit["status"]): "success" | "warning" | "error" | "dim" {
+	if (status === "exhausted") return "error";
+	if (status === "warning") return "warning";
+	if (status === "ok") return "success";
+	return "dim";
+}
+
+function renderUsageBar(limit: UsageLimit, uiTheme: typeof theme): string {
+	const fraction = resolveFraction(limit);
+	if (fraction === undefined) {
+		return uiTheme.fg("dim", `[${"·".repeat(BAR_WIDTH)}]`);
+	}
+	const clamped = Math.min(Math.max(fraction, 0), 1);
+	const filled = Math.round(clamped * BAR_WIDTH);
+	const filledBar = "█".repeat(filled);
+	const emptyBar = "░".repeat(Math.max(0, BAR_WIDTH - filled));
+	const color = resolveStatusColor(limit.status);
+	return `${uiTheme.fg("dim", "[")}${uiTheme.fg(color, filledBar)}${uiTheme.fg("dim", emptyBar)}${uiTheme.fg("dim", "]")}`;
+}
+
+function renderUsageReports(reports: UsageReport[], uiTheme: typeof theme, nowMs: number): string {
+	const lines: string[] = [];
+	const latestFetchedAt = Math.max(...reports.map((report) => report.fetchedAt ?? 0));
+	const headerSuffix = latestFetchedAt ? ` (${formatDuration(nowMs - latestFetchedAt)} ago)` : "";
+	lines.push(uiTheme.bold(uiTheme.fg("accent", `Usage${headerSuffix}`)));
+	const grouped = new Map<string, UsageReport[]>();
+	for (const report of reports) {
+		const list = grouped.get(report.provider) ?? [];
+		list.push(report);
+		grouped.set(report.provider, list);
+	}
+	const providerEntries = Array.from(grouped.entries())
+		.map(([provider, providerReports]) => ({
+			provider,
+			providerReports,
+			totalUsage: resolveProviderUsageTotal(providerReports),
+		}))
+		.sort((a, b) => {
+			if (a.totalUsage !== b.totalUsage) return a.totalUsage - b.totalUsage;
+			return a.provider.localeCompare(b.provider);
+		});
+
+	for (const { provider, providerReports } of providerEntries) {
+		lines.push("");
+		const providerName = formatProviderName(provider);
+
+		const limitGroups = new Map<
+			string,
+			{ label: string; windowLabel: string; limits: UsageLimit[]; reports: UsageReport[] }
+		>();
+		for (const report of providerReports) {
+			for (const limit of report.limits) {
+				const windowId = limit.window?.id ?? limit.scope.windowId ?? "default";
+				const key = `${formatLimitTitle(limit)}|${windowId}`;
+				const windowLabel = limit.window?.label ?? windowId;
+				const entry = limitGroups.get(key) ?? {
+					label: formatLimitTitle(limit),
+					windowLabel,
+					limits: [],
+					reports: [],
+				};
+				entry.limits.push(limit);
+				entry.reports.push(report);
+				limitGroups.set(key, entry);
+			}
+		}
+
+		const providerAllZero = isZeroUsageGroup(Array.from(limitGroups.values()).flatMap((group) => group.limits));
+		if (providerAllZero) {
+			const providerTitle = `${resolveStatusIcon("ok", uiTheme)} ${uiTheme.fg("accent", `${providerName} (0%)`)}`;
+			lines.push(uiTheme.bold(providerTitle));
+			continue;
+		}
+
+		lines.push(uiTheme.bold(uiTheme.fg("accent", providerName)));
+
+		for (const group of limitGroups.values()) {
+			const entries = group.limits.map((limit, index) => ({
+				limit,
+				report: group.reports[index],
+				fraction: resolveFraction(limit),
+				index,
+			}));
+			entries.sort((a, b) => {
+				const aFraction = a.fraction ?? -1;
+				const bFraction = b.fraction ?? -1;
+				if (aFraction !== bFraction) return bFraction - aFraction;
+				return a.index - b.index;
+			});
+			const sortedLimits = entries.map((entry) => entry.limit);
+			const sortedReports = entries.map((entry) => entry.report);
+
+			const status = resolveAggregateStatus(sortedLimits);
+			const statusIcon = resolveStatusIcon(status, uiTheme);
+			if (isZeroUsageGroup(sortedLimits)) {
+				const resetText = resolveResetRange(sortedLimits, nowMs);
+				const resetSuffix = resetText ? ` | ${resetText}` : "";
+				const windowSuffix = formatWindowSuffix(group.label, group.windowLabel, uiTheme);
+				lines.push(
+					`${statusIcon} ${uiTheme.bold(group.label)} ${windowSuffix} ${uiTheme.fg(
+						"dim",
+						`0%${resetSuffix}`,
+					)}`.trim(),
+				);
+				continue;
+			}
+
+			const windowSuffix = formatWindowSuffix(group.label, group.windowLabel, uiTheme);
+			lines.push(`${statusIcon} ${uiTheme.bold(group.label)} ${windowSuffix}`.trim());
+			const accountLabels = sortedLimits.map((limit, index) =>
+				padColumn(formatAccountHeader(limit, sortedReports[index], index, nowMs), COLUMN_WIDTH),
+			);
+			lines.push(`  ${accountLabels.join(" ")}`.trimEnd());
+			const bars = sortedLimits.map((limit) => padColumn(renderUsageBar(limit, uiTheme), COLUMN_WIDTH));
+			lines.push(`  ${bars.join(" ")} ${formatAggregateAmount(sortedLimits)}`.trimEnd());
+			const resetText = sortedLimits.length <= 1 ? resolveResetRange(sortedLimits, nowMs) : null;
+			if (resetText) {
+				lines.push(`  ${uiTheme.fg("dim", resetText)}`.trimEnd());
+			}
+			const notes = sortedLimits.flatMap((limit) => limit.notes ?? []);
+			if (notes.length > 0) {
+				lines.push(`  ${uiTheme.fg("dim", notes.join(" • "))}`.trimEnd());
+			}
+		}
+
+		// No per-provider footer; global header shows last check.
+	}
+
+	return lines.join("\n");
+}

package/src/modes/interactive/controllers/input-controller.ts

@@ -1,4 +1,6 @@
-import { rm } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import type { FileHandle } from "node:fs/promises";
+import { open, rm } from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
@@ -143,6 +145,16 @@ export class InputController {
 
 			if (!text) return;
 
+			// Continue shortcuts: "." or "c" sends empty message (agent continues, no visible message)
+			if (text === "." || text === "c") {
+				if (this.ctx.onInputCallback) {
+					this.ctx.editor.setText("");
+					this.ctx.pendingImages = [];
+					this.ctx.onInputCallback({ text: "" });
+				}
+				return;
+			}
+
 			const runner = this.ctx.session.extensionRunner;
 			let inputImages = this.ctx.pendingImages.length > 0 ? [...this.ctx.pendingImages] : undefined;
 
@@ -199,6 +211,11 @@ export class InputController {
 				this.ctx.editor.setText("");
 				return;
 			}
+			if (text === "/usage") {
+				await this.ctx.handleUsageCommand();
+				this.ctx.editor.setText("");
+				return;
+			}
 			if (text === "/changelog") {
 				this.ctx.handleChangelogCommand();
 				this.ctx.editor.setText("");
@@ -614,6 +631,25 @@ export class InputController {
 		this.ctx.showStatus(`Thinking blocks: ${this.ctx.hideThinkingBlock ? "hidden" : "visible"}`);
 	}
 
+	private getEditorTerminalPath(): string | null {
+		if (process.platform === "win32") {
+			return null;
+		}
+		return "/dev/tty";
+	}
+
+	private async openEditorTerminalHandle(): Promise<FileHandle | null> {
+		const terminalPath = this.getEditorTerminalPath();
+		if (!terminalPath) {
+			return null;
+		}
+		try {
+			return await open(terminalPath, "r+");
+		} catch {
+			return null;
+		}
+	}
+
 	async openExternalEditor(): Promise<void> {
 		// Determine editor (respect $VISUAL, then $EDITOR)
 		const editorCmd = process.env.VISUAL || process.env.EDITOR;
@@ -625,23 +661,27 @@ export class InputController {
 		const currentText = this.ctx.editor.getText();
 		const tmpFile = path.join(os.tmpdir(), `omp-editor-${nanoid()}.omp.md`);
 
+		let ttyHandle: FileHandle | null = null;
 		try {
 			// Write current content to temp file
 			await Bun.write(tmpFile, currentText);
 
 			// Stop TUI to release terminal
+			ttyHandle = await this.openEditorTerminalHandle();
 			this.ctx.ui.stop();
 
 			// Split by space to support editor arguments (e.g., "code --wait")
 			const [editor, ...editorArgs] = editorCmd.split(" ");
 
-			// Spawn editor synchronously with inherited stdio for interactive editing
-			const child = Bun.spawn([editor, ...editorArgs, tmpFile], {
-				stdin: "inherit",
-				stdout: "inherit",
-				stderr: "inherit",
+			const stdio: [number | "inherit", number | "inherit", number | "inherit"] = ttyHandle
+				? [ttyHandle.fd, ttyHandle.fd, ttyHandle.fd]
+				: ["inherit", "inherit", "inherit"];
+
+			const child = spawn(editor, [...editorArgs, tmpFile], { stdio });
+			const exitCode = await new Promise<number>((resolve, reject) => {
+				child.once("exit", (code, signal) => resolve(code ?? (signal ? -1 : 0)));
+				child.once("error", (error) => reject(error));
 			});
-			const exitCode = await child.exited;
 
 			// On successful exit (exitCode 0), replace editor content
 			if (exitCode === 0) {
@@ -649,6 +689,10 @@ export class InputController {
 				this.ctx.editor.setText(newContent);
 			}
 			// On non-zero exit, keep original text (no action needed)
+		} catch (error) {
+			this.ctx.showWarning(
+				`Failed to open external editor: ${error instanceof Error ? error.message : String(error)}`,
+			);
 		} finally {
 			// Clean up temp file
 			try {
@@ -657,6 +701,10 @@ export class InputController {
 				// Ignore cleanup errors
 			}
 
+			if (ttyHandle) {
+				await ttyHandle.close();
+			}
+
 			// Restart TUI
 			this.ctx.ui.start();
 			this.ctx.ui.requestRender();

package/src/modes/interactive/interactive-mode.ts

@@ -5,7 +5,7 @@
 
 import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { AssistantMessage, ImageContent, Message } from "@oh-my-pi/pi-ai";
+import type { AssistantMessage, ImageContent, Message, UsageReport } from "@oh-my-pi/pi-ai";
 import type { Component, Loader, SlashCommand } from "@oh-my-pi/pi-tui";
 import {
 	CombinedAutocompleteProvider,
@@ -187,6 +187,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			{ name: "share", description: "Share session as a secret GitHub gist" },
 			{ name: "copy", description: "Copy last agent message to clipboard" },
 			{ name: "session", description: "Show session info and stats" },
+			{ name: "usage", description: "Show provider usage and limits" },
 			{ name: "extensions", description: "Open Extension Control Center dashboard" },
 			{ name: "status", description: "Alias for /extensions" },
 			{ name: "changelog", description: "Show changelog entries" },
@@ -613,6 +614,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.commandController.handleSessionCommand();
 	}
 
+	handleUsageCommand(reports?: UsageReport[] | null): Promise<void> {
+		return this.commandController.handleUsageCommand(reports);
+	}
+
 	handleChangelogCommand(): void {
 		this.commandController.handleChangelogCommand();
 	}

package/src/modes/interactive/types.ts

@@ -1,5 +1,5 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { AssistantMessage, ImageContent, Message } from "@oh-my-pi/pi-ai";
+import type { AssistantMessage, ImageContent, Message, UsageReport } from "@oh-my-pi/pi-ai";
 import type { Component, Container, Loader, Spacer, Text, TUI } from "@oh-my-pi/pi-tui";
 import type { AgentSession, AgentSessionEvent } from "../../core/agent-session";
 import type { ExtensionUIContext } from "../../core/extensions/index";
@@ -134,6 +134,7 @@ export interface InteractiveModeContext {
 	handleShareCommand(): Promise<void>;
 	handleCopyCommand(): Promise<void>;
 	handleSessionCommand(): void;
+	handleUsageCommand(reports?: UsageReport[] | null): Promise<void>;
 	handleChangelogCommand(): void;
 	handleHotkeysCommand(): void;
 	handleDumpCommand(): Promise<void>;