@gavin-hu/my-pi-agent 0.13.1 → 0.14.0

package/extensions/bytefly/header/component.ts

@@ -18,9 +18,9 @@ import { BODY_INDENT } from "../../../lib/tui/indent.ts";
 import { RULE_GLYPH } from "../../../lib/tui/rules.ts";
 import { paint } from "../../../lib/tui/tokens.ts";
 import { updateMarker } from "../update/format.ts";
-import { HEADER_CONFIG, type HelpEntry } from "./config.ts";
+import { HEADER_CONFIG, type HeaderHeight, type HelpEntry } from "./config.ts";
 
-/** The header's shape, resolved once per apply so `render` stays cheap. */
+/** The header's shape: everything but the live terminal height is resolved once per apply. */
 export interface HeaderView {
 	/** Print Pi's version on the agent line. */
 	showVersion: boolean;
@@ -28,6 +28,8 @@ export interface HeaderView {
 	halfBlocks: boolean;
 	/** Columns of left margin: Pi's output pad, so the nameplate sits on the transcript margin. */
 	pad: number;
+	/** Terminal rows, when the host reports them; short terminals shed help rows. */
+	rows?: number;
 	/** A newer published version of this package, when one is known. */
 	latest?: string;
 }
@@ -35,6 +37,15 @@ export interface HeaderView {
 /** The mark block is four columns on both rows, so the identity column aligns. */
 const MARK_WIDTH = 4;
 
+/**
+ * The tallest shape whose threshold the terminal meets. An unknown or impossible
+ * height keeps the full header, so a host without terminal rows still reads well.
+ */
+function heightShape(rows: number | undefined): HeaderHeight {
+	if (rows === undefined || !Number.isFinite(rows) || rows <= 0) return HEADER_CONFIG.heights[0];
+	return HEADER_CONFIG.heights.find((shape) => rows >= shape.minRows) ?? HEADER_CONFIG.heights[0];
+}
+
 /** Pad a themed mark line to the block width with plain spaces. */
 function markBlock(line: string): string {
 	return line + " ".repeat(Math.max(0, MARK_WIDTH - visibleWidth(line)));
@@ -81,7 +92,7 @@ export class ByteflyHeader implements Component {
 		const w = Math.max(1, width);
 		const theme = this.getTheme();
 		const view = this.view();
-		const viewKey = `${view.showVersion}:${view.halfBlocks}:${view.pad}:${view.latest ?? ""}`;
+		const viewKey = `${view.showVersion}:${view.halfBlocks}:${view.pad}:${view.latest ?? ""}:${view.rows ?? ""}`;
 		const keys = this.keySignature();
 		if (
 			this.cachedWidth === w &&
@@ -111,6 +122,7 @@ export class ByteflyHeader implements Component {
 	private build(w: number, theme: Theme, view: HeaderView): string[] {
 		const { nameRole, chromeRole, detailRole, updateRole, chromeTagline, chromeName, chromeVersion, help } =
 			HEADER_CONFIG;
+		const shape = heightShape(view.rows);
 		const padWidth = Math.max(0, Math.min(Math.floor(view.pad), Math.max(0, w - 1)));
 		const pad = " ".repeat(padWidth);
 		const [markTop, markBottom] = markLines(theme, view.halfBlocks);
@@ -145,13 +157,17 @@ export class ByteflyHeader implements Component {
 
 		// The header owns its leading blank: Pi mounts the built-in header inside
 		// `Spacer(1)`s, but the `quietStartup: true` branch that hands this header the
-		// screen adds none, and `setHeader` swaps only the header child.
+		// screen adds none, and `setHeader` swaps only the header child. A short
+		// terminal gives that row back, then sheds whole help groups.
 		return [
-			"",
+			...(shape.blank ? [""] : []),
 			this.identityLine(pad, markTop, agentCell, w),
 			this.identityLine(pad, markBottom, chromeCell, w),
 			this.rule(theme, w, pad),
-			...help.map((row) => this.helpLine(theme, w, row, padWidth)),
+			...shape.helpRows.flatMap((index) => {
+				const group = help[index];
+				return group ? [this.helpLine(theme, w, group, padWidth)] : [];
+			}),
 		];
 	}
 
@@ -193,6 +209,12 @@ export class ByteflyHeader implements Component {
 }
 
 /** Header factory passed to `ctx.ui.setHeader`. */
-export function createHeader(getTheme: () => Theme, view: () => HeaderView): (tui: TUI, theme: Theme) => Component {
-	return () => new ByteflyHeader(getTheme, view, VERSION);
+export function createHeader(
+	getTheme: () => Theme,
+	view: (rows: number | undefined) => HeaderView,
+): (tui: TUI, theme: Theme) => Component {
+	// Read the height on every render, so a terminal resize reflows the header
+	// instead of keeping the shape it was installed with. Tests may pass a bare
+	// object as the host, so the terminal is optional at the boundary.
+	return (tui) => new ByteflyHeader(getTheme, () => view(tui.terminal?.rows), VERSION);
 }

package/extensions/bytefly/header/config.ts

@@ -19,6 +19,16 @@ export type HelpEntry =
 	| { readonly binding: AppKeybinding; readonly description: string }
 	| { readonly raw: string; readonly description: string };
 
+/** How much of the help block a terminal height can carry. */
+export interface HeaderHeight {
+	/** Smallest terminal height, in rows, this shape applies to. Taller tiers come first. */
+	readonly minRows: number;
+	/** Help groups to print, by index in `help`; a group is dropped whole. */
+	readonly helpRows: readonly number[];
+	/** Open with a blank row above the nameplate. */
+	readonly blank: boolean;
+}
+
 /** The header's shape and content. */
 export interface HeaderConfig {
 	/** The agent's name, shown before its version. */
@@ -49,6 +59,12 @@ export interface HeaderConfig {
 	readonly chromeVersion: string;
 	/** Grouped help rows, printed one line each under the rule. */
 	readonly help: readonly (readonly HelpEntry[])[];
+	/**
+	 * The height ladder, tallest first: the first tier the terminal meets decides
+	 * which help groups print and whether the leading blank row survives. The
+	 * floor is `minRows: 0`, so a short terminal keeps the nameplate and rule.
+	 */
+	readonly heights: readonly HeaderHeight[];
 }
 
 export const HEADER_CONFIG: HeaderConfig = {
@@ -89,4 +105,10 @@ export const HEADER_CONFIG: HeaderConfig = {
 			{ binding: "app.clipboard.pasteImage", description: "paste files" },
 		],
 	],
+	heights: [
+		{ minRows: 28, helpRows: [0, 1, 2], blank: true },
+		{ minRows: 22, helpRows: [0, 2], blank: true },
+		{ minRows: 16, helpRows: [2], blank: true },
+		{ minRows: 0, helpRows: [], blank: false },
+	],
 };

package/extensions/bytefly/header/register.ts

@@ -55,11 +55,12 @@ export function registerHeader(pi: ExtensionAPI, updates: UpdateSource = createU
 		// value the tool frame and the notice inset by. An older host without
 		// `getSettings` keeps the default margin.
 		const pad = pi.getSettings?.().outputPad ?? DEFAULT_HOST_PAD;
-		const view = (): HeaderView => ({
+		const view = (rows: number | undefined): HeaderView => ({
 			showVersion: HEADER_CONFIG.showVersion,
 			halfBlocks,
 			pad,
 			latest: updates.latest(),
+			rows,
 		});
 		ctx.ui.setHeader(createHeader(() => ctx.ui.theme, view));
 	};

package/extensions/bytefly/index.ts

@@ -4,13 +4,13 @@
  * (the two-line, width-adaptive status bar with its price calculation),
  * `message/` (the user-message nameplate), `notice/` (the shared transcript
  * notice renderer), `block/` (the unified tool-block frame), `separator/` (the
- * transcript turn rule), `working/` (the live elapsed counter on Pi's working
- * row), `panel/` (the unified `/bytefly` screen and its
+ * transcript turn rule), `working/` (the live run line on Pi's working row),
+ * `panel/` (the unified `/bytefly` screen and its
  * `doctor` report), `doctor/` (the `run_doctor` tool and its session-scoped
  * probe runtime), `notify/` (OS notifications for unattended runs), and
  * `update/` (the published-version check behind the header's update marker).
  *
- * The header, footer, turn rule, and working timer are installed only in
+ * The header, footer, turn rule, and working line are installed only in
  * interactive (`tui`) sessions, and are always on; the user-message marker,
  * notice, and tool blocks register at load and take effect wherever a
  * transcript renders. `pi config` turns bytefly's chrome off. The panel and doctor work

package/extensions/bytefly/notify/config.ts

@@ -18,7 +18,7 @@ import { cleanString, loadConfigSection } from "../../../lib/config.ts";
 import { NOTIFY_METHODS, type NotifyConfig, type NotifyMethod } from "./types.ts";
 
 /** A notification title longer than this is clamped; it is a label, not a message. */
-const MAX_TITLE_LENGTH = 40;
+export const MAX_TITLE_LENGTH = 40;
 
 export const DEFAULT_NOTIFY_CONFIG: NotifyConfig = {
 	enabled: false,

package/extensions/bytefly/panel/commands.ts

@@ -172,7 +172,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 		if (section === "settings" && ctx.mode !== "tui") {
 			const stores = createSettingsStores(cwd, agentDir, trusted);
 			const settings = makeSettings({ stores, cwd, agentDir, trusted, onError: settingsNotice });
-			ctx.ui.notify(formatSettingsListing(settings.views("global"), "global"), "info");
+			ctx.ui.notify(formatSettingsListing(settings.views("global")), "info");
 			return;
 		}
 

package/extensions/bytefly/panel/format.ts

@@ -31,7 +31,7 @@ export interface SummarySegment {
 }
 
 /** Row and problem counts over a model. */
-export interface PanelCounts {
+interface PanelCounts {
 	extensions: number;
 	/** Rows switched off in settings (the picker's checkbox), not the env flag. */
 	off: number;
@@ -113,28 +113,21 @@ export function sectionSegments(active: PanelSection): SummarySegment[] {
 export function settingsSummarySegments(scope: PanelScope, count: number): SummarySegment[] {
 	return [
 		{ text: scope === "global" ? "Global" : "Project", color: "accent" },
-		{ text: `${count} ${count === 1 ? "setting" : "settings"}`, color: "meta" },
+		{ text: `${count} settings`, color: "meta" },
 	];
 }
 
-/** The Settings headline for non-TUI modes, e.g. `bytefly: Settings · Global · 5 settings`. */
-export function formatSettingsHeadline(scope: PanelScope, count: number): string {
-	return `bytefly: Settings · ${settingsSummarySegments(scope, count)
-		.map((segment) => segment.text)
-		.join(" · ")}`;
-}
-
 /**
- * The grouped Settings listing for non-TUI modes. The project form names the
- * missing app rows rather than leaving their absence unexplained.
+ * The Settings headline for non-TUI modes, e.g. `bytefly: Settings · Global · 16 settings`.
+ * The listing only ever reads the personal document, so the scope is not a parameter.
  */
-export function formatSettingsListing(views: readonly SettingView[], scope: PanelScope): string {
-	const lines = [formatSettingsHeadline(scope, views.length)];
-	if (scope === "project") lines.push("", "  App settings are Global only.");
-	if (views.length === 0) {
-		lines.push("", "No settings found.");
-		return lines.join("\n");
-	}
+export function formatSettingsHeadline(count: number): string {
+	return `bytefly: Settings · Global · ${count} settings`;
+}
+
+/** The grouped Settings listing for non-TUI modes. */
+export function formatSettingsListing(views: readonly SettingView[]): string {
+	const lines = [formatSettingsHeadline(views.length)];
 	for (const group of groupViews(views)) {
 		lines.push("", `${group.label} (${group.views.length})`);
 		for (const view of group.views) {
@@ -152,7 +145,7 @@ export function formatHeadline(model: PanelModel, scope: PanelScope, options: Pa
 }
 
 /** A row's glyph and verdict, drawn from its enablement and health axes. */
-export interface RowBadge {
+interface RowBadge {
 	/** The status glyph, or `undefined` when the row has nothing to say. */
 	glyph?: string;
 	/** The role the glyph is painted in. */

package/extensions/bytefly/panel/settings-runtime.ts

@@ -1,20 +1,28 @@
 /**
  * The stateful Settings section: one snapshot of the two config documents and
- * the personal settings, the dirty flag, and the two write paths.
+ * the personal settings, the dirty flag, and the writes it offers.
  *
  * App rows are written through Pi's `SettingsStore` (personal file only), and
- * `bytefly.json` rows through the per-key writer, so an edit cannot disturb a
- * sibling key or another extension's section. A failed write leaves the
- * snapshot untouched and reports through `onError`; the screen never shows a
- * value the file did not accept.
+ * `bytefly.json` rows through the per-key writers, so an edit cannot disturb a
+ * sibling key or another extension's section. A reset deletes one leaf through the
+ * same path, and the JSON pane reads the section the row belongs to. A failed
+ * write leaves the snapshot untouched and reports through `onError`; the screen
+ * never shows a value the file did not accept.
  */
 
 import { join } from "node:path";
 import { CONFIG_DIR_NAME, type QuietStartup } from "@earendil-works/pi-coding-agent";
-import { readJson, SHARED_CONFIG_FILE, writeConfigValueAt } from "../../../lib/config.ts";
+import {
+	configSection,
+	configValueAt,
+	readJson,
+	SHARED_CONFIG_FILE,
+	unsetConfigValueAt,
+	writeConfigValueAt,
+} from "../../../lib/config.ts";
 import type { SettingsStore, WriteScope } from "../picker/types.ts";
 import {
-	countSettings,
+	type ConfigSectionName,
 	nextValue,
 	type SettingDescriptor,
 	type SettingsSnapshot,
@@ -23,7 +31,6 @@ import {
 	settingViews,
 	storedValue,
 	textError,
-	validValue,
 } from "./settings.ts";
 
 /** Host seams for the Settings runtime. */
@@ -40,11 +47,14 @@ export interface SettingsRuntimeDeps {
 /** What the panel needs from the runtime. */
 export interface SettingsSurface {
 	views(scope: WriteScope): SettingView[];
-	count(scope: WriteScope): number;
 	/** Cycle an enum or toggle a boolean. */
 	change(scope: WriteScope, id: string): Promise<void>;
 	/** Store a value the user typed; `false` when the row refused it. */
 	setValue(scope: WriteScope, id: string, raw: string): Promise<boolean>;
+	/** Delete the focused row's leaf so its default applies; `false` when nothing changed. */
+	reset(scope: WriteScope, id: string): Promise<boolean>;
+	/** The raw `bytefly.json` section for `scope`, for the JSON pane. */
+	sectionDocument(scope: WriteScope, section: ConfigSectionName): unknown;
 	isDirty(): boolean;
 }
 
@@ -62,8 +72,8 @@ export function configPath(scope: WriteScope, cwd: string, agentDir: string): st
 function readSnapshot(deps: SettingsRuntimeDeps): SettingsSnapshot {
 	return {
 		app: deps.stores.global.globalSettings(),
-		global: readJson(join(deps.agentDir, SHARED_CONFIG_FILE)) ?? {},
-		project: deps.trusted ? (readJson(join(deps.cwd, CONFIG_DIR_NAME, SHARED_CONFIG_FILE)) ?? {}) : {},
+		global: readJson(configPath("global", deps.cwd, deps.agentDir)) ?? {},
+		project: deps.trusted ? (readJson(configPath("project", deps.cwd, deps.agentDir)) ?? {}) : {},
 	};
 }
 
@@ -133,10 +143,15 @@ export function createSettingsRuntime(deps: SettingsRuntimeDeps): SettingsRuntim
 
 	return {
 		views: (scope) => settingViews(snapshot, scope),
-		count: (scope) => countSettings(scope),
 		change: async (scope, id) => {
 			const row = SETTING_ROWS.find((entry) => entry.id === id);
 			if (!row) return;
+			// Only a boolean or an enum cycles; a text row is stored from its editor,
+			// so refusing here keeps `nextValue`'s cycle contract honest.
+			if (row.kind === "text") {
+				deps.onError?.(`${row.label} is edited as text, not cycled.`);
+				return;
+			}
 			const refused = refusal(row, scope, deps.trusted);
 			if (refused !== undefined) {
 				deps.onError?.(refused);
@@ -145,10 +160,6 @@ export function createSettingsRuntime(deps: SettingsRuntimeDeps): SettingsRuntim
 			const current = settingViews(snapshot, scope).find((entry) => entry.id === id);
 			if (!current) return;
 			const next = nextValue(row, current.value);
-			if (!validValue(row, next.value)) {
-				deps.onError?.(`Cannot save ${row.label}: unknown value.`);
-				return;
-			}
 			try {
 				await write(scope, row, next.value);
 			} catch (error) {
@@ -159,8 +170,8 @@ export function createSettingsRuntime(deps: SettingsRuntimeDeps): SettingsRuntim
 		},
 		async setValue(scope, id, raw) {
 			const row = SETTING_ROWS.find((entry) => entry.id === id);
-			if (!row || row.kind !== "text") {
-				deps.onError?.(`${row?.label ?? id} cannot be edited as text.`);
+			if (!row) {
+				deps.onError?.(`${id} is not a setting.`);
 				return false;
 			}
 			const refused = refusal(row, scope, deps.trusted);
@@ -182,6 +193,39 @@ export function createSettingsRuntime(deps: SettingsRuntimeDeps): SettingsRuntim
 			committed();
 			return true;
 		},
+		async reset(scope, id) {
+			const row = SETTING_ROWS.find((entry) => entry.id === id);
+			if (!row) {
+				deps.onError?.(`${id} is not a setting.`);
+				return false;
+			}
+			if (row.source === "app") {
+				deps.onError?.(`${row.label} is a Pi setting; Pi has no unset, so set the value instead.`);
+				return false;
+			}
+			const refused = refusal(row, scope, deps.trusted);
+			if (refused !== undefined) {
+				deps.onError?.(refused);
+				return false;
+			}
+			const config = row.config;
+			if (!config) return false;
+			const document = scope === "global" ? snapshot.global : snapshot.project;
+			if (configValueAt(configSection(document, config.section), config.path) === undefined) {
+				deps.onError?.(`${row.label} is already at its default.`);
+				return false;
+			}
+			try {
+				unsetConfigValueAt(configPath(scope, deps.cwd, deps.agentDir), config.section, config.path);
+			} catch (error) {
+				deps.onError?.(`Could not reset ${row.label}: ${error instanceof Error ? error.message : String(error)}`);
+				return false;
+			}
+			committed();
+			return true;
+		},
+		sectionDocument: (scope, section) =>
+			configSection(scope === "global" ? snapshot.global : snapshot.project, section),
 		isDirty: () => dirty,
 		onChange: (listener) => {
 			listeners.add(listener);