pi-daybreak-param 0.1.1 → 0.1.3

package/README.md

@@ -10,16 +10,16 @@ Persistent `/daybreak` configuration and explicit `access_programs.cyber` reques
 pi -e ./src/index.ts --daybreak-cyber daybreak_blue
 ```
 
-Install from GitHub:
+Install from npm:
 
 ```sh
-pi install git:github.com/MercuriusDream/pi-daybreak-param
+pi install npm:pi-daybreak-param
 ```
 
-Once published to npm:
+Or install from GitHub (choose one source, not both):
 
 ```sh
-pi install npm:pi-daybreak-param
+pi install git:github.com/MercuriusDream/pi-daybreak-param
 ```
 
 For local development: `pi install /absolute/path/to/pi-daybreak-param`. Reload an active Pi session with `/reload` after installation.
@@ -43,6 +43,12 @@ Menu and command selections are saved atomically to `~/.pi/agent/daybreak.json`
 
 An absent config intentionally means inherit/default. A malformed or unreadable config is an error that blocks OpenAI requests—even with a valid CLI flag. Correct it explicitly using `/daybreak <selection>` or repair the file. Other providers are outside the wrapper's scope.
 
+## Footer display
+
+When Pi runs in its interactive TUI, the extension uses Pi's supported `setFooter()` API to render **model • requested program • reasoning effort** on one line (for example `gpt-6-sol • daybreak blue • max`). No separate Daybreak extension-status line is added. `standard` appears when explicitly selected; `default` adds no label. Configuration errors appear inline as `daybreak config error`, with their full reason available from `/daybreak status` and the startup notification. The label is the **requested** selection, not proof the server granted Daybreak.
+
+Pi does not expose an API to insert one segment into its built-in footer, so the extension replaces that footer in TUI mode and reproduces its basic path, usage, context, model, and other extensions' status lines. Other extensions replacing the footer can override this display (or vice versa). Non-interactive modes do not install a custom footer. `/reload` may be needed in an already-running session after updating the package.
+
 ## Why `/daybreak`, not `/settings`?
 
 Pi 0.99.1's built-in `/settings` has hardcoded rows and callbacks, with no supported extension setting registration API. `/daybreak` therefore provides its own supported selection dialog and persistent configuration, without monkey-patching Pi or replacing the built-in settings screen.

package/docs/research.md

@@ -36,7 +36,7 @@ Uses `pi.on`, `registerFlag`, `registerCommand`, `ctx.ui.setStatus`, and a thin
 - Explicit `default` is no override; `standard` is explicit opt-out. Explicit selection preserves other top-level request fields and other access-program keys.
 - Invalid CLI configuration is retained as an error state that blocks OpenAI calls; it is not converted into default behavior. Invalid commands throw. Invalid payloads/endpoint/model identity throw when applying an explicit selection.
 - Selection changes wait for idle. Menu/command selections persist atomically in the agent directory's `daybreak.json`. Each `session_start` validates that file, then selects the CLI override or saved value. Invalid reads/writes block OpenAI requests; only a genuinely absent config has the intentional initial inherit state.
-- UI status is guarded by `ctx.hasUI`. CLI flag works in print/JSON/RPC modes; no custom terminal UI is needed.
+- Pi's `setStatus` renders on a separate footer line and cannot place text between the model and thinking effort. In TUI mode the extension now uses the documented `ctx.ui.setFooter()` API to reproduce key footer content and render the requested cyber program inline between model and effort. It clears its old `daybreak-param` status, preserves other extension statuses, and shows config errors inline. It does not install a footer in print/JSON/RPC modes. Other custom-footer extensions may conflict; Pi has no supported compositional inline segment hook.
 - Scope: requests through the `openai` provider and `openai-responses` API. An explicit program requires the canonical `https://api.openai.com/v1` endpoint and matching payload model ID. Both auth methods are preserved. Other providers, including legacy Codex, are outside this registration.
 - Existing payload handlers run before this final transformation. `default` does not remove values configured in `samplingParams` or added elsewhere. Another provider replacement can conflict with this registration.
 - No automatic retries with another program/model, permission-error masking, approval claims, or removal of safeguards.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-daybreak-param",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "Persistent /daybreak access-program selection for Pi's OpenAI and Sign in with ChatGPT requests",
   "license": "MIT",
@@ -12,6 +12,6 @@
   "publishConfig": { "access": "public", "registry": "https://registry.npmjs.org/" },
   "keywords": ["pi-package"],
   "pi": { "extensions": ["./src/index.ts"] },
-  "peerDependencies": { "@earendil-works/pi-coding-agent": "*", "@earendil-works/pi-ai": "*" },
+  "peerDependencies": { "@earendil-works/pi-coding-agent": "*", "@earendil-works/pi-ai": "*", "@earendil-works/pi-tui": "*" },
   "scripts": { "test": "bun test" }
 }

package/src/controller.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Api, SimpleStreamOptions, StreamFunction } from "@earendil-works/pi-ai";
-import { isDirectOpenAI, MODES, parseMode, selectCyberProgram, type CyberMode } from "./payload.ts";
+import { MODES, parseMode, selectCyberProgram, type CyberMode } from "./payload.ts";
+import { createFooter } from "./footer.ts";
 import type { ModeStore } from "./config.ts";
 
 const LABELS: Record<CyberMode, string> = {
@@ -18,11 +19,12 @@ export function registerDaybreak(pi: ExtensionAPI, streamOpenAI: StreamFunction<
 
 	let mode: CyberMode = "default";
 	let configError: Error | undefined = new Error("Daybreak configuration has not been initialized. OpenAI request blocked.");
-	const refreshStatus = (ctx: ExtensionContext) => {
-		if (ctx.hasUI) {
-			ctx.ui.setStatus("daybreak-param", configError ? "Cyber config: ERROR" :
-				mode !== "default" && isDirectOpenAI(ctx.model) ? `Cyber request: ${mode} (not verified)` : undefined);
-		}
+	const installFooter = (ctx: ExtensionContext) => {
+		if (ctx.mode !== "tui") return;
+		// Pi offers no public hook into one segment of its built-in footer. A
+		// custom footer is necessary for an inline model • program • effort label.
+		ctx.ui.setStatus("daybreak-param", undefined); // clear stale status from older versions
+		ctx.ui.setFooter((_tui, theme, data) => createFooter(ctx, theme, data, () => mode, () => configError));
 	};
 
 	pi.on("session_start", (_event, ctx) => {
@@ -42,22 +44,22 @@ export function registerDaybreak(pi: ExtensionAPI, streamOpenAI: StreamFunction<
 			configError = new Error(`Daybreak configuration error: ${error instanceof Error ? error.message : String(error)} OpenAI requests are blocked until corrected.`);
 			if (ctx.hasUI) ctx.ui.notify(configError.message, "error");
 		}
-		refreshStatus(ctx);
+		installFooter(ctx);
 	});
-	pi.on("model_select", (_event, ctx) => refreshStatus(ctx));
+	pi.on("model_select", (_event, ctx) => installFooter(ctx));
 
 	pi.registerCommand("daybreak", {
 		description: `Configure persistent cyber selection, or /daybreak status: ${MODES.join(" | ")}`,
 		handler: async (args, ctx) => {
 			let value = args.trim();
 			if (value === "status") {
-				ctx.ui.notify(configError?.message ?? `Cyber request selection: ${mode}. This is not confirmation of Daybreak access.`, configError ? "error" : "info");
+				ctx.ui.notify(configError?.message ?? `Cyber request selection: ${mode}.`, configError ? "error" : "info");
 				return;
 			}
 			await ctx.waitForIdle();
 			if (!value) {
 				if (!ctx.hasUI) throw new Error("Use /daybreak <selection> or --daybreak-cyber in non-UI mode.");
-				const selected = await ctx.ui.select(`Cyber request selection: ${configError ? "CONFIG ERROR" : mode} (access not verified)`, Object.values(LABELS));
+				const selected = await ctx.ui.select(`Cyber request selection: ${configError ? "CONFIG ERROR" : mode}`, Object.values(LABELS));
 				if (selected === undefined) return; // Explicit user cancellation changes nothing.
 				const entry = Object.entries(LABELS).find(([, label]) => label === selected);
 				if (!entry) throw new Error("Invalid Daybreak menu selection.");
@@ -69,12 +71,10 @@ export function registerDaybreak(pi: ExtensionAPI, streamOpenAI: StreamFunction<
 				store.write(next);
 			} catch (error) {
 				configError = new Error(`Failed to save Daybreak configuration: ${error instanceof Error ? error.message : String(error)} OpenAI requests are blocked until corrected.`);
-				refreshStatus(ctx);
 				throw configError;
 			}
 			mode = next;
 			configError = undefined;
-			refreshStatus(ctx);
 			ctx.ui.notify(next === "default"
 				? "Saved: inherit. Extension override disabled; existing payload and server defaults are unchanged."
 				: `Saved: request ${next} on OpenAI Responses calls. OpenAI still checks model compatibility and your approved access.`, "info");

package/src/footer.ts

@@ -0,0 +1,93 @@
+import { homedir } from "node:os";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import type { ExtensionContext, ReadonlyFooterDataProvider } from "@earendil-works/pi-coding-agent";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { CyberMode } from "./payload.ts";
+
+const DISPLAY: Record<Exclude<CyberMode, "default">, string> = {
+	standard: "standard",
+	daybreak_blue: "daybreak blue",
+	daybreak_red: "daybreak red",
+};
+
+export function modelLabel(model: ExtensionContext["model"], thinking: string | undefined, mode: CyberMode, error?: Error): string {
+	const slug = model?.id ?? "no-model";
+	const program = model?.provider === "openai" && error ? " • daybreak config error" :
+		model?.provider === "openai" && mode !== "default" ? ` • ${DISPLAY[mode]}` : "";
+	const effort = model?.reasoning ? ` • ${thinking && thinking !== "off" ? thinking : "thinking off"}` : "";
+	return `${slug}${program}${effort}`;
+}
+
+function tokens(value: number): string {
+	if (value < 1000) return `${value}`;
+	if (value < 10000) return `${(value / 1000).toFixed(1)}k`;
+	if (value < 1000000) return `${Math.round(value / 1000)}k`;
+	if (value < 10000000) return `${(value / 1000000).toFixed(1)}M`;
+	return `${Math.round(value / 1000000)}M`;
+}
+
+function cwdLabel(cwd: string): string {
+	const home = homedir();
+	const relativePath = relative(resolve(home), resolve(cwd));
+	return relativePath === "" ? "~" :
+		relativePath !== ".." && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath)
+			? `~${sep}${relativePath}` : cwd;
+}
+
+function cleanStatus(text: string): string {
+	return text.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
+}
+
+export function createFooter(ctx: ExtensionContext, theme: Theme, data: ReadonlyFooterDataProvider, getMode: () => CyberMode, getError: () => Error | undefined) {
+	return {
+		invalidate() {},
+		render(width: number): string[] {
+			if (width <= 0) return [];
+			let path = cwdLabel(ctx.sessionManager.getCwd());
+			const branch = data.getGitBranch();
+			if (branch) path += ` (${branch})`;
+			const name = ctx.sessionManager.getSessionName();
+			if (name) path += ` • ${name}`;
+			const entries = ctx.sessionManager.getEntries();
+			let input = 0, output = 0, cacheRead = 0, cacheWrite = 0, cost = 0;
+			for (const entry of entries) {
+				if (entry.type !== "message") continue;
+				const message = entry.message;
+				if (message.role !== "assistant" && message.role !== "toolResult") continue;
+				const usage = message.usage;
+				if (!usage) continue;
+				input += usage.input;
+				output += usage.output;
+				cacheRead += usage.cacheRead;
+				cacheWrite += usage.cacheWrite;
+				cost += usage.cost.total;
+			}
+			const stats = [
+				input ? `↑${tokens(input)}` : "",
+				output ? `↓${tokens(output)}` : "",
+				cacheRead ? `R${tokens(cacheRead)}` : "",
+				cacheWrite ? `W${tokens(cacheWrite)}` : "",
+				cost ? `$${cost.toFixed(3)}` : "",
+			].filter(Boolean);
+			const context = ctx.getContextUsage();
+			stats.push(`${context?.percent == null ? "?" : `${context.percent.toFixed(1)}%`}/${tokens(context?.contextWindow ?? ctx.model?.contextWindow ?? 0)}`);
+			const left = stats.join(" ");
+			let right = modelLabel(ctx.model, ctx.thinkingLevel, getMode(), getError());
+			if (data.getAvailableProviderCount() > 1 && ctx.model) right = `(${ctx.model.provider}) ${right}`;
+			const available = Math.max(0, width - visibleWidth(left) - 2);
+			if (visibleWidth(right) > available) right = truncateToWidth(right, available, "");
+			const padding = " ".repeat(Math.max(1, width - visibleWidth(left) - visibleWidth(right)));
+			const lines = [
+				truncateToWidth(theme.fg("dim", path), width, ""),
+				truncateToWidth(theme.fg("dim", left + padding + right), width, ""),
+			];
+			const statuses = [...data.getExtensionStatuses().entries()]
+				.filter(([key]) => key !== "daybreak-param")
+				.sort(([a], [b]) => a.localeCompare(b))
+				.map(([, text]) => cleanStatus(text));
+			if (statuses.length) lines.push(truncateToWidth(statuses.join(" "), width, ""));
+			return lines;
+		},
+	};
+}