@gavin-hu/my-pi-agent 0.18.0 → 0.20.0

package/extensions/bytefly/panel/commands.ts

@@ -1,12 +1,14 @@
 /**
- * The `/bytefly` surface: one command, `/bytefly [doctor] [settings] [skills] [update] [extension] [refresh]`.
+ * The `/bytefly` surface: one command, `/bytefly [doctor] [settings] [skills] [update] [upgrade] [extension] [refresh]`.
  *
  * Without a section word it opens the extension screen: the dock in `tui`, the
  * grouped listing elsewhere. `settings` opens the Settings section, or prints
  * its grouped listing outside `tui` without resolving packages. `skills` opens
  * the Skills section and lists the resolved skills in text modes. `update`
  * re-runs the published-version check and reports what it found, which is the
- * one place a request is made on demand. With `doctor` it produces the doctor
+ * one place a request is made on demand; `upgrade` asks Pi's own package manager
+ * to install what that check found, behind a confirmation, so the two verbs stay
+ * one job each — ask, and act. With `doctor` it produces the doctor
  * report — the same text `run_doctor` returns — for the whole set or one named
  * extension; in `tui` the report is the dock screen. Discovery, the doctor
  * probe, and the dirty-to-reload confirm all live here. The doctor runtime and
@@ -27,7 +29,11 @@ import type { UpdateHandle } from "../update/register.ts";
 import { createSettingsStores, discoverResources, type DiscoveryDeps } from "../picker/discovery.ts";
 import { createPickerRuntime, type PickerRuntime } from "../picker/runtime.ts";
 import type { Discovery } from "../picker/types.ts";
+import { usageRecords } from "../footer/collect/entries.ts";
+import { loadByteflyConfig } from "../footer/price/config.ts";
+import { createPricer } from "../footer/price/price.ts";
 import { formatListing, formatSettingsListing, SKILL_NOUN } from "./format.ts";
+import { pricesReport } from "./prices.ts";
 import { buildPanelModel, buildSkillModel, extensionName } from "./join.ts";
 import { createSettingsRuntime, type SettingsRuntime, type SettingsRuntimeDeps } from "./settings-runtime.ts";
 import { loadSkillIndex, resolvedSkillPaths, type SkillIndex } from "./skills.ts";
@@ -63,14 +69,23 @@ function selectableNames(discovery: Discovery): Set<string> {
 }
 
 /** The values a bare `/bytefly <tab>` offers, in screen order. */
-const FIRST_TOKENS = ["doctor", "settings", "skills", "update", ...Object.keys(REQUIREMENTS), "refresh"] as const;
+const FIRST_TOKENS = [
+	"doctor",
+	"prices",
+	"settings",
+	"skills",
+	"update",
+	"upgrade",
+	...Object.keys(REQUIREMENTS),
+	"refresh",
+] as const;
 
 /**
  * Argument completions. The host replaces the whole argument text with the
  * returned `value`, so a second token returns the full `doctor <name>` or
  * `<name> refresh` argument rather than just the word. `/bytefly settings`,
- * `/bytefly skills`, and `/bytefly update` take no name, and `refresh` is never
- * followed by another token.
+ * `/bytefly skills`, `/bytefly update`, and `/bytefly upgrade` take no name, and
+ * `refresh` is never followed by another token.
  */
 function completions(prefix: string): Array<{ value: string; label: string }> | null {
 	const [first = "", second, ...rest] = prefix.trimStart().split(/\s+/);
@@ -79,7 +94,8 @@ function completions(prefix: string): Array<{ value: string; label: string }> |
 		const options = FIRST_TOKENS.filter((option) => option.startsWith(first));
 		return options.length > 0 ? options.map((option) => ({ value: `${option} `, label: option })) : null;
 	}
-	if (first === "settings" || first === "skills" || first === "refresh" || first === "update") return null;
+	if (first === "settings" || first === "skills" || first === "refresh" || first === "update" || first === "upgrade")
+		return null;
 	const options = (first === "doctor" ? [...Object.keys(REQUIREMENTS), "refresh"] : ["refresh"]).filter((option) =>
 		option.startsWith(second),
 	);
@@ -87,7 +103,7 @@ function completions(prefix: string): Array<{ value: string; label: string }> |
 }
 
 /** Which bytefly surface the arguments select. */
-type PanelMode = "screen" | "doctor" | "update";
+type PanelMode = "screen" | "doctor" | "update" | "upgrade" | "prices";
 
 /** `/bytefly [doctor] [settings] [extension] [refresh]`, parsed. */
 interface PanelArgs {
@@ -109,6 +125,13 @@ function parseArgs(args: string): PanelArgs {
 	// `update` is already a refresh of the published version, so a stray `refresh`
 	// beside it is accepted and ignored rather than refused.
 	if (rest[0] === "update") return { mode: "update", section: "extensions", refresh };
+	// `upgrade` is the same subject as `update`, one verb further: it installs what a
+	// check found. Refusing to fold them into one word is what keeps a command that
+	// writes behind a confirmation instead of behind an argument.
+	if (rest[0] === "upgrade") return { mode: "upgrade", section: "extensions", refresh };
+	// `prices` answers a question about this session's totals, so it takes no name and
+	// no refresh: it prices what the session holds, once, when asked.
+	if (rest[0] === "prices") return { mode: "prices", section: "extensions", refresh };
 	if (rest[0] === "settings") return { mode: "screen", section: "settings", name: rest[1], refresh };
 	if (rest[0] === "skills") return { mode: "screen", section: "skills", name: rest[1], refresh };
 	return { mode: "screen", section: "extensions", name: rest[0], refresh };
@@ -166,6 +189,18 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 			return;
 		}
 		const cwd = ctx.cwd ?? process.cwd();
+		// `/bytefly prices` answers one question about the session and resolves nothing: it
+		// prices what the transcript already recorded and names what that left out. It runs
+		// in every mode, because the footer that would carry the same fact exists only in
+		// `tui`.
+		if (mode === "prices") {
+			const config = loadByteflyConfig(cwd);
+			const active = ctx.model ? { provider: ctx.model.provider, model: ctx.model.id } : undefined;
+			const scanned = usageRecords(ctx.sessionManager.getEntries(), active);
+			ctx.ui.notify(pricesReport(createPricer(config)(scanned.records), config.currency).join("\n"), "info");
+			return;
+		}
+
 		const agentDir = getAgentDir();
 		const trusted = ctx.isProjectTrusted();
 		const themes = settingsThemeNames(ctx);
@@ -190,6 +225,24 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 			return;
 		}
 
+		// `/bytefly upgrade` is the only path here that writes, and it writes outside
+		// the session: Pi's package manager replaces the installed files, so the
+		// confirmation and the reload line are part of the answer, not decoration.
+		if (mode === "upgrade") {
+			const confirmed = await ctx.ui.confirm(
+				"Update packages?",
+				`Run Pi's package manager for every configured package, then reload to use it.`,
+			);
+			if (!confirmed) {
+				ctx.ui.notify("bytefly: update cancelled.", "info");
+				return;
+			}
+			const outcome = await deps.update.apply();
+			const { text, severity } = updateOutcomeText(outcome, pkg.version);
+			ctx.ui.notify(text, severity);
+			return;
+		}
+
 		// Settings outside `tui` prints its grouped listing without resolving
 		// packages or probing the doctor.
 		if (section === "settings" && ctx.mode !== "tui") {
@@ -293,6 +346,13 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 					refresh: async (force) => {
 						reports = await deps.doctor.probeAll({ refresh: force === true });
 					},
+					reload: async () => {
+						// The reload takes the session, so the screen asks first and says
+						// what will change; a refusal leaves the dock exactly as it was.
+						const reload = await ctx.ui.confirm("Reload to apply changes?", "Changes take effect after a reload.");
+						if (!reload) return;
+						await ctx.reload();
+					},
 					onClose: () => {
 						// A late error falls back to the transcript, never a disposed screen.
 						panel = undefined;

package/extensions/bytefly/panel/filter.ts

@@ -0,0 +1,68 @@
+/**
+ * The two filters the screen offers: a text query, and a switch that keeps only
+ * the rows worth acting on.
+ *
+ * A filter is part of the model build, not a post-pass over a rendered list, so a
+ * group's count and the range row stay truthful about what is on screen. The chips
+ * the tab row prints come from the same object, so the screen cannot say it is
+ * filtered without saying by what.
+ *
+ * Value-only: pure predicates over rows and views.
+ */
+
+import type { SummarySegment } from "./format.ts";
+import { rowBadge } from "./format.ts";
+import type { PanelRow } from "./types.ts";
+import type { SettingView } from "./settings.ts";
+
+/** What the reader narrowed the list to. */
+export interface PanelFilter {
+	/** Case-insensitive text matched against a row's name, path and source. */
+	query: string;
+	/** Keep only rows that need attention (settings: values changed from default). */
+	attentionOnly: boolean;
+}
+
+/** The unfiltered state. */
+export const NO_FILTER: PanelFilter = { query: "", attentionOnly: false };
+
+/** Whether anything is narrowed, so the chrome can say so. */
+export function isFiltering(filter: PanelFilter): boolean {
+	return filter.query.trim() !== "" || filter.attentionOnly;
+}
+
+/** Whether the row's own text mentions `query`. */
+function mentions(text: readonly (string | undefined)[], query: string): boolean {
+	const needle = query.toLowerCase();
+	return text.some((value) => value !== undefined && value.toLowerCase().includes(needle));
+}
+
+/**
+ * Whether a resource row survives the filter. The query reaches the picker's path
+ * and source as well as the name, because "which file is this" is the question a
+ * reader asks of a row they cannot place.
+ */
+export function rowMatches(row: PanelRow, filter: PanelFilter): boolean {
+	if (filter.attentionOnly && rowBadge(row).glyph === undefined) return false;
+	if (!mentions([row.label, row.key, row.item?.path, row.report?.extension, row.skill?.description], filter.query)) {
+		return false;
+	}
+	return true;
+}
+
+/** Whether a settings row survives the filter; "changed" means not at its default. */
+export function settingMatches(view: SettingView, filter: PanelFilter): boolean {
+	if (filter.attentionOnly && view.origin === "default") return false;
+	return mentions([view.label, view.id, view.description, view.valueLabel], filter.query);
+}
+
+/** The chips the tab row shows while a filter is on. */
+export function filterChips(filter: PanelFilter, kind: "rows" | "settings"): SummarySegment[] {
+	const chips: SummarySegment[] = [];
+	const query = filter.query.trim();
+	if (query !== "") chips.push({ text: `/${query}`, color: "meta" });
+	if (filter.attentionOnly) {
+		chips.push({ text: kind === "settings" ? "changed only" : "needs attention", color: "warn" });
+	}
+	return chips;
+}

package/extensions/bytefly/panel/format.ts

@@ -127,23 +127,24 @@ const SECTION_LABELS: Record<PanelSection, string> = {
 	settings: "Settings",
 };
 
+/** One section's name, as the tab row prints it. */
+export function sectionLabel(section: PanelSection): string {
+	return SECTION_LABELS[section];
+}
+
 /**
- * The section bar's segments, in screen order. The active section takes the
- * accent and the others recede, so the bar reads as a left-to-right switch.
+ * The header's attention line: the worst thing the screen knows, then how many
+ * changes a reload would apply. `all clear` is said out loud rather than left
+ * blank, so the header never reads as "nothing loaded".
  */
-export function sectionSegments(active: PanelSection): SummarySegment[] {
-	return SECTION_ORDER.map((section) => ({
-		text: SECTION_LABELS[section],
-		color: active === section ? "accent" : "faint",
-	}));
-}
-
-/** The Settings section's counts: the scope and how many rows it shows. */
-export function settingsSummarySegments(scope: PanelScope, count: number): SummarySegment[] {
-	return [
-		{ text: scope === "global" ? "Global" : "Project", color: "accent" },
-		{ text: `${count} settings`, color: "meta" },
-	];
+export function attentionSegments(counts: PanelCounts, dirty: boolean): SummarySegment[] {
+	const segments: SummarySegment[] = [];
+	if (counts.missing > 0) segments.push({ text: `${counts.missing} missing`, color: "bad" });
+	else if (counts.degraded > 0) segments.push({ text: `${counts.degraded} degraded`, color: "warn" });
+	else if (counts.off > 0) segments.push({ text: `${counts.off} off`, color: "faint" });
+	else segments.push({ text: "all clear", color: "ok" });
+	if (dirty) segments.push({ text: "unsaved changes", color: "warn" });
+	return segments;
 }
 
 /**

package/extensions/bytefly/panel/join.ts

@@ -31,6 +31,17 @@ export function extensionName(path: string): string {
 	return basename(dirname(path));
 }
 
+/**
+ * The name a resource is called by on screen: the directory for an entry file
+ * (`…/worktree/index.ts`, `…/pdf/SKILL.md`), and the file's own stem otherwise, so
+ * a flat `extensions/auto.ts` is `auto` rather than the directory every flat file
+ * shares.
+ */
+export function resourceName(path: string): string {
+	const stem = basename(path).replace(/\.(ts|js|mjs|cjs|md)$/u, "");
+	return stem === "index" || stem === "SKILL" ? basename(dirname(path)) : stem;
+}
+
 /** Row key for a report that has no resolved extension item. */
 function reportKey(name: string): string {
 	return `report:${name}`;
@@ -46,13 +57,24 @@ export interface PanelJoinOptions {
 	agentDir: string;
 	/** Narrow to one extension directory or report name, or `undefined` for the full list. */
 	filter?: string;
+	/** Keep only the rows this accepts; a group's count follows what survives. */
+	where?: (row: PanelRow) => boolean;
 	/** Which resource kind the list is, for labels and grouping. */
 	kind?: ResourceKind;
 }
 
+/**
+ * The rows one group list produces, group headings included. The screen measures
+ * a section's height from this rather than from a built model, so a section it is
+ * not showing costs no `SKILL.md` read.
+ */
+export function groupedEntryCount(items: readonly ResourceItem[], agentDir: string, kind: ResourceKind): number {
+	return buildEntries([...items], agentDir, kind).length;
+}
+
 /** Build the merged model for the current items and reports. */
 export function buildPanelModel(options: PanelJoinOptions): PanelModel {
-	const { items, reports, agentDir, filter, kind = "extensions" } = options;
+	const { items, reports, agentDir, filter, where, kind = "extensions" } = options;
 	const byName = new Map(reports.map((report) => [report.extension, report]));
 
 	// A directory name may claim a report only when exactly one unique resource
@@ -60,7 +82,7 @@ export function buildPanelModel(options: PanelJoinOptions): PanelModel {
 	// the report and it stays available to the trailing `Not resolved` group.
 	const pathsByName = new Map<string, Set<string>>();
 	for (const item of items) {
-		const name = extensionName(item.path);
+		const name = resourceName(item.path);
 		const paths = pathsByName.get(name) ?? new Set<string>();
 		paths.add(resourceKey(item));
 		pathsByName.set(name, paths);
@@ -83,12 +105,23 @@ export function buildPanelModel(options: PanelJoinOptions): PanelModel {
 		const report = unambiguous(name) ? byName.get(name) : undefined;
 		if (report) claimed.add(name);
 		if (filter !== undefined && name !== filter) continue;
-		rows.push({ key: resourceKey(item), item, report, label: entry.label, group: current?.key ?? "" });
+		// The row is named for the resource, not for its file: a name is only unique
+		// enough to be a name when one resource uses it, which is the same rule that
+		// lets a directory claim a report. Otherwise the picker's `folder/file.ts`
+		// stays, because two rows would otherwise read alike.
+		const label = unambiguous(name) ? resourceName(item.path) : entry.label;
+		const row: PanelRow = { key: resourceKey(item), item, report, label, group: current?.key ?? "" };
+		if (where !== undefined && !where(row)) continue;
+		rows.push(row);
 		if (current) current.count += 1;
 	}
 
 	const extras = reports.filter(
-		(report) => !claimed.has(report.extension) && (filter === undefined || report.extension === filter),
+		(report) =>
+			!claimed.has(report.extension) &&
+			(filter === undefined || report.extension === filter) &&
+			(where === undefined ||
+				where({ key: reportKey(report.extension), report, label: report.extension, group: REPORT_ONLY_GROUP })),
 	);
 	if (extras.length > 0) {
 		const group: PanelGroup = { key: REPORT_ONLY_GROUP, label: REPORT_ONLY_LABEL, count: extras.length };
@@ -111,14 +144,24 @@ export function buildSkillModel(options: {
 	items: readonly ResourceItem[];
 	index: ReadonlyMap<string, SkillInfo>;
 	agentDir: string;
+	where?: (row: PanelRow) => boolean;
 }): PanelModel {
-	const model = buildPanelModel({ items: options.items, reports: [], agentDir: options.agentDir, kind: "skills" });
-	return {
-		groups: model.groups,
-		rows: model.rows.map((row) => {
-			const skill = row.item ? options.index.get(row.item.path) : undefined;
-			if (skill === undefined) return row;
-			return { ...row, label: skill.name ?? row.label, skill };
-		}),
-	};
+	// The filter runs after the join: a skill's name and its `SKILL.md` facts are
+	// what a reader searches and what decides whether it needs attention.
+	const model = buildPanelModel({
+		items: options.items,
+		reports: [],
+		agentDir: options.agentDir,
+		kind: "skills",
+	});
+	const joined = model.rows.map((row) => {
+		const skill = row.item ? options.index.get(row.item.path) : undefined;
+		if (skill === undefined) return row;
+		return { ...row, label: skill.name ?? row.label, skill };
+	});
+	const rows = options.where === undefined ? joined : joined.filter(options.where);
+	const groups = model.groups
+		.map((group) => ({ ...group, count: rows.filter((row) => row.group === group.key).length }))
+		.filter((group) => group.count > 0);
+	return { groups, rows };
 }

package/extensions/bytefly/panel/prices.ts

@@ -0,0 +1,43 @@
+/**
+ * The `/bytefly prices` report: which models this session could not price.
+ *
+ * A record nothing priced contributes no cost, so the footer's total is smaller than
+ * the work done and the reason is a *model*, not a record count. This is the answer to
+ * the question the footer can only hint at: the keys, in the `price.rates` vocabulary,
+ * and the one line saying what to do with them.
+ *
+ * Nothing here quotes a price: a rate is the user's to state, and inventing one is the
+ * rate table this command exists instead of.
+ */
+
+import { sanitizeLine } from "../../../lib/format.ts";
+import type { PricedUsage } from "../footer/types.ts";
+import { formatCost } from "../footer/render/format.ts";
+import { recordsText } from "../footer/unpriced.ts";
+import type { Currency } from "../footer/price/types.ts";
+
+/** How many keys the report prints before it counts the rest. */
+export const REPORTED_MODELS = 8;
+
+/**
+ * The report as the lines a reader gets.
+ *
+ * The headline says what the total is and how much of the session it leaves out; one
+ * line per key says what to add; the last line says where to add it. Pure: the caller
+ * has already priced the session.
+ */
+export function pricesReport(priced: PricedUsage, currency: Currency): string[] {
+	const models = priced.unpricedModels;
+	if (models.length === 0) return ["bytefly: every record in this session has a rate — nothing to add."];
+	const count = models.reduce((total, model) => total + model.records, 0);
+	const headline =
+		`bytefly: ${formatCost(priced.cost, currency)} priced · ` +
+		`${recordsText(count)} in ${models.length === 1 ? "1 model" : `${models.length} models`} ${count === 1 ? "has" : "have"} no rate`;
+	const keys = models
+		.slice(0, REPORTED_MODELS)
+		.map((model) => `  ${sanitizeLine(model.key)} · ${recordsText(model.records)}`);
+	const rest = models.length - keys.length;
+	if (rest > 0) keys.push(`  +${rest} more`);
+	keys.push('  add these under "price.rates" in bytefly.json — a key may be `*`, or a prefix like `gpt-*`.');
+	return [headline, ...keys];
+}

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

@@ -88,12 +88,6 @@ function applyAppSetting(store: SettingsStore, row: SettingDescriptor, raw: stri
 		case "byteflyUi":
 			store.setQuietStartup(value as QuietStartup);
 			return;
-		case "outputPad":
-			store.setOutputPad(value as 0 | 1);
-			return;
-		case "showHardwareCursor":
-			store.setShowHardwareCursor(value as boolean);
-			return;
 		case "theme":
 			store.setTheme(value as string);
 			return;