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

package/extensions/bytefly/update/register.ts

@@ -1,47 +1,57 @@
 /**
- * The update check's lifecycle: reuse the cached answer or read the registry once
- * per interactive session, record a newer version, and announce it once per load.
+ * The update surface's lifecycle: ask Pi's package manager which configured
+ * packages are behind, cache the snapshot, and announce it once per load.
  *
- * The request is fired without awaiting. Pi awaits `session_start` handlers, so
- * a slow registry would otherwise hold the first prompt; Pi's own version check
- * is asynchronous for the same reason. Every result that is not a strictly newer
- * version is silent, and a generation counter keeps a request that resolves
- * after shutdown from writing into the next session's state.
+ * Pi would draw its own `Package Updates Available` block from the same method
+ * after `session_start`. bytefly suppresses that block, asks the captured
+ * original check itself, and draws the single notice. The request is fired
+ * without awaiting: Pi awaits `session_start` handlers, and a slow npm/git check
+ * must not hold the first prompt.
  *
- * A cached answer with a timestamp is what makes a long-lived session different
- * from a fresh one: a session that starts inside the window reuses the last read
- * instead of repeating it, and `recheck()` ignores the window so `/bytefly update`
- * can look again without a restart. `/bytefly` and `doctor` do not report the
- * version: an available update is not a prerequisite problem.
+ * The 24-hour cache is keyed by the working directory and the effective package
+ * sources, so a project switch or an install/removal invalidates it. A cache hit
+ * costs no package-manager call; `/bytefly update` ignores the window and re-runs
+ * the check on demand.
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import pkg from "../../../package.json";
 import { isOffline } from "../../../lib/env.ts";
-import { isFresh, readUpdateCache, updateCachePath, writeUpdateCache, type UpdateCacheEntry } from "./cache.ts";
-import { fetchLatestVersion } from "./check.ts";
-import { updateNotice } from "./format.ts";
+import {
+	isFresh,
+	readUpdateCache,
+	updateCacheKey,
+	updateCachePath,
+	writeUpdateCache,
+	type UpdateCacheEntry,
+} from "./cache.ts";
+import { fetchAvailableUpdates, fetchLatestVersion } from "./check.ts";
+import { isOwnPackage, updateNotice } from "./format.ts";
 import type { UpdateOutcome, UpdateSource } from "./state.ts";
+import { suppressPiPackageUpdates, type UpdateSuppression } from "./suppress.ts";
+import type { PackageUpdate, PackageUpdateCheck } from "./types.ts";
 import { isNewerVersion } from "./version.ts";
 
 /** The cache, as the lifecycle sees it: read on start, written after a read. */
 export interface UpdateCache {
-	/** The last recorded answer, or `undefined` for a miss. */
+	/** The last recorded snapshot, or `undefined` for a miss. */
 	read(): UpdateCacheEntry | undefined;
-	/** Record an answer; a throw is treated as a miss. */
+	/** Record a snapshot; a throw is treated as a miss. */
 	write(entry: UpdateCacheEntry): void;
 }
 
 /** What `registerUpdate` returns, so the panel can re-run the check on demand. */
 export interface UpdateHandle {
-	/** Read the registry now, ignoring the cache window. Never throws. */
+	/** Read the package list now, ignoring the cache window. Never throws. */
 	recheck(): Promise<UpdateOutcome>;
 }
 
-/** Test seams; production uses the registry read, `PI_OFFLINE`, and the agent dir. */
+/** Test seams; production uses Pi's package manager, its cache, and the agent dir. */
 export interface UpdateDeps {
-	/** Replace the registry read; a rejection counts as no answer. */
+	/** Replace the package-manager read. */
+	readUpdates?: (ctx: ExtensionContext, check: PackageUpdateCheck) => Promise<PackageUpdate[] | undefined>;
+	/** Replace the registry read that names this package's new version. */
 	fetchLatest?: () => Promise<string | undefined>;
 	/** Replace the `PI_OFFLINE` check. */
 	isOffline?: () => boolean;
@@ -49,7 +59,9 @@ export interface UpdateDeps {
 	cache?: UpdateCache;
 	/** Replace the clock the cache timestamp is read from. */
 	now?: () => number;
-	/** Called once a newer version is recorded, so a mounted surface repaints. */
+	/** Replace the host suppression; defaults to patching Pi's package manager. */
+	suppress?: () => UpdateSuppression;
+	/** Called once a snapshot is recorded, so a mounted surface repaints. */
 	onUpdate?: () => void;
 }
 
@@ -61,52 +73,112 @@ function diskCache(): UpdateCache {
 			try {
 				writeUpdateCache(updateCachePath(getAgentDir()), entry);
 			} catch {
-				// A read-only agent directory costs the next session one request, nothing more.
+				// A read-only agent directory costs the next session one check, nothing more.
 			}
 		},
 	};
 }
 
 /**
- * Register the check. `updates` is the same store the header reads, so recording
- * a version and calling `onUpdate` is what puts the marker on screen.
+ * Register the update lifecycle. `updates` is the store the header reads, so
+ * recording a snapshot is what puts this package's marker on screen.
  */
 export function registerUpdate(pi: ExtensionAPI, updates: UpdateSource, deps: UpdateDeps = {}): UpdateHandle {
+	const readUpdates =
+		deps.readUpdates ??
+		((ctx, check) =>
+			fetchAvailableUpdates({
+				cwd: ctx.cwd,
+				agentDir: getAgentDir(),
+				projectTrusted: ctx.isProjectTrusted(),
+				checkForAvailableUpdates: check,
+			}));
 	const readLatest = deps.fetchLatest ?? (() => fetchLatestVersion());
 	const offline = deps.isOffline ?? isOffline;
 	const cache = deps.cache ?? diskCache();
 	const now = deps.now ?? Date.now;
+	const suppress = deps.suppress ?? suppressPiPackageUpdates;
 	// A session is announced at most once per load, even if `session_start` fires
 	// again after a resume or a session replacement.
 	let announced = false;
 	let generation = 0;
+	let suppression: UpdateSuppression | undefined;
+	let context: ExtensionContext | undefined;
+	const fallbackCheck: PackageUpdateCheck = (manager) => manager.checkForAvailableUpdates();
+	const activeCheck = (): PackageUpdateCheck => suppression?.check ?? fallbackCheck;
 
-	/** Record a newer version and repaint the marker. */
-	const paint = (latest: string): void => {
-		if (!isNewerVersion(latest, pkg.version)) return;
+	/** Identity of the settings a snapshot is read under. */
+	const keyFor = (ctx: ExtensionContext): string => updateCacheKey(ctx.cwd, pi.getSettings?.()?.packages);
+
+	/** A cache write never turns a read into a failed check. */
+	const writeCache = (entry: UpdateCacheEntry): void => {
+		try {
+			cache.write(entry);
+		} catch {
+			// The next session performs one more check; this one already has its answer.
+		}
+	};
+
+	/** This package's new version in a snapshot, when it is actually newer. */
+	const ownLatestOf = (entry: UpdateCacheEntry): string | undefined => {
+		if (!entry.latest || !isNewerVersion(entry.latest, pkg.version)) return undefined;
+		return entry.updates.some(isOwnPackage) ? entry.latest : undefined;
+	};
+
+	/** Paint the header marker, or clear it when this package is current. */
+	const paint = (latest?: string): void => {
+		if (updates.latest() === latest) return;
 		updates.set(latest);
 		deps.onUpdate?.();
 	};
 
-	/** The once-per-load transcript notice, posted only for a strictly newer version. */
-	const announce = (latest: string): void => {
-		if (announced || !isNewerVersion(latest, pkg.version)) return;
+	/** The once-per-load transcript notice, posted only for a non-empty list. */
+	const announce = (entry: UpdateCacheEntry): void => {
+		if (announced || entry.updates.length === 0) return;
 		announced = true;
-		pi.sendMessage(updateNotice(pkg.version, latest));
+		pi.sendMessage(updateNotice(entry.updates, pkg.version, ownLatestOf(entry)));
 	};
 
-	/** One answer, from the cache or the registry: paint the marker, announce it once. */
+	/** One snapshot: paint the marker and, when it has rows, announce it once. */
 	const record = (entry: UpdateCacheEntry): void => {
-		paint(entry.latest);
-		announce(entry.latest);
+		paint(ownLatestOf(entry));
+		announce(entry);
 	};
 
-	const check = async (token: number): Promise<void> => {
+	/** Offline: the cached marker is advisory, but no notice is posted. */
+	const recordMarkerOnly = (entry: UpdateCacheEntry): void => {
+		paint(ownLatestOf(entry));
+	};
+
+	/** Resolve this package's version label, dropping an equal or older answer. */
+	const resolveOwnLatest = async (own: PackageUpdate | undefined): Promise<string | undefined> => {
+		if (!own) return undefined;
+		let latest: string | undefined;
 		try {
-			const latest = await readLatest();
-			if (latest === undefined || token !== generation) return;
-			const entry = { latest, checkedAt: now() };
-			cache.write(entry);
+			latest = await readLatest();
+		} catch {
+			return undefined;
+		}
+		return latest && isNewerVersion(latest, pkg.version) ? latest : undefined;
+	};
+
+	const check = async (ctx: ExtensionContext, token: number): Promise<void> => {
+		try {
+			const list = await readUpdates(ctx, activeCheck());
+			if (token !== generation) return;
+			// A check that could not run is not an empty answer: caching it would tell
+			// the next session "up to date" for a day and clear a marker that may still
+			// be right, so leave both alone and try again next time.
+			if (list === undefined) return;
+			const latest = await resolveOwnLatest(list.find(isOwnPackage));
+			if (token !== generation) return;
+			const entry: UpdateCacheEntry = {
+				key: keyFor(ctx),
+				checkedAt: now(),
+				updates: list,
+				...(latest ? { latest } : {}),
+			};
+			writeCache(entry);
 			record(entry);
 		} catch {
 			// A background check never surfaces an error: the session does not know it ran.
@@ -114,45 +186,62 @@ export function registerUpdate(pi: ExtensionAPI, updates: UpdateSource, deps: Up
 	};
 
 	pi.on("session_start", (_event, ctx) => {
-		// The marker lives in bytefly's header and the notice in a transcript, so a
-		// non-interactive run has nothing to draw and makes no request.
+		// `/bytefly update` can answer in any mode; only the TUI installs the host
+		// shim and posts a notice.
+		context = ctx;
 		if (ctx.mode !== "tui") return;
+		suppression ??= suppress();
+		const cached = cache.read();
+		const key = keyFor(ctx);
 		if (offline()) {
-			// No request, so the window does not matter: the cached answer is the best
-			// one available, and the marker is advisory.
-			const cached = cache.read();
-			if (cached) record(cached);
+			// No request, so the window does not matter: the cached marker is the best
+			// answer available, and no notice is posted from a stale list.
+			if (cached && cached.key === key) recordMarkerOnly(cached);
 			return;
 		}
-		const cached = cache.read();
-		if (cached && isFresh(cached, now())) {
+		if (cached && cached.key === key && isFresh(cached, now())) {
 			record(cached);
 			return;
 		}
 		if (announced) return;
-		void check(generation);
+		void check(ctx, generation);
 	});
 
 	pi.on("session_shutdown", () => {
-		// Invalidate any request still in flight and drop what this session found.
+		// Invalidate any request still in flight, drop what this session found, and
+		// give Pi's own check back to the host.
 		generation++;
 		updates.set();
+		suppression?.restore();
+		suppression = undefined;
+		context = undefined;
 	});
 
 	return {
 		async recheck() {
 			if (offline()) return { kind: "offline" };
-			let latest: string | undefined;
+			if (!context) return { kind: "failed" };
+			let list: PackageUpdate[];
 			try {
-				latest = await readLatest();
+				const found = await readUpdates(context, activeCheck());
+				if (found === undefined) return { kind: "failed" };
+				list = found;
 			} catch {
 				return { kind: "failed" };
 			}
-			if (latest === undefined) return { kind: "failed" };
-			cache.write({ latest, checkedAt: now() });
+			const latest = await resolveOwnLatest(list.find(isOwnPackage));
+			const entry: UpdateCacheEntry = {
+				key: keyFor(context),
+				checkedAt: now(),
+				updates: list,
+				...(latest ? { latest } : {}),
+			};
+			writeCache(entry);
 			// The caller prints the answer, so this path never posts a notice.
 			paint(latest);
-			return isNewerVersion(latest, pkg.version) ? { kind: "available", latest } : { kind: "current", latest };
+			return list.length > 0
+				? { kind: "available", updates: list, ...(latest ? { ownLatest: latest } : {}) }
+				: { kind: "current" };
 		},
 	};
 }

package/extensions/bytefly/update/state.ts

@@ -9,6 +9,8 @@
  * cleared on shutdown, so a reload starts from nothing.
  */
 
+import type { PackageUpdate } from "./types.ts";
+
 /** The store the header reads and the update lifecycle writes. */
 export interface UpdateSource {
 	/** The newer published version, or `undefined` when none is known. */
@@ -25,8 +27,8 @@ export interface UpdateSource {
 export type UpdateOutcome =
 	| { kind: "offline" }
 	| { kind: "failed" }
-	| { kind: "current"; latest: string }
-	| { kind: "available"; latest: string };
+	| { kind: "current" }
+	| { kind: "available"; updates: readonly PackageUpdate[]; ownLatest?: string };
 
 /** A store holding at most one version. */
 export function createUpdateState(): UpdateSource {

package/extensions/bytefly/update/suppress.ts

@@ -0,0 +1,66 @@
+/**
+ * Pi suppresses its own package-update block while bytefly owns the surface.
+ *
+ * Pi draws `Package Updates Available` from `InteractiveMode.run()` after the
+ * session starts, with no setting or extension event to turn it off. The one
+ * public seam is the package manager it calls: replacing
+ * `checkForAvailableUpdates` with an empty result suppresses that block, while
+ * the captured original still serves bytefly's own query. The patch is
+ * process-wide, so it is installed at `session_start` and restored at
+ * `session_shutdown`.
+ *
+ * A future host that changes the method shape makes the patch a no-op rather
+ * than an error; the update surface then falls back to Pi's block.
+ */
+
+import { DefaultPackageManager } from "@earendil-works/pi-coding-agent";
+import type { PackageUpdate, PackageUpdateCheck } from "./types.ts";
+
+/** A patchable class prototype, kept narrow so a test needs no host object. */
+export interface PackageManagerPrototype {
+	checkForAvailableUpdates: PackageUpdateCheck;
+}
+
+/** The installed suppression: the real check, and how to restore Pi's method. */
+export interface UpdateSuppression {
+	/** The original method, bound at call time so it still sees its manager. */
+	readonly check: PackageUpdateCheck;
+	/** Put Pi's method back; safe to call more than once. */
+	restore(): void;
+}
+
+/** Marker for the installed patch, so a second registration reuses it. */
+const SUPPRESSION = Symbol.for("@gavin-hu/my-pi-agent/pi-update-suppression");
+
+interface MarkedPrototype extends PackageManagerPrototype {
+	[SUPPRESSION]?: UpdateSuppression;
+}
+
+/**
+ * Replace Pi's package-update check with one that reports nothing.
+ *
+ * `prototype` is a seam for tests; production passes Pi's
+ * `DefaultPackageManager.prototype`. When the method is missing, the returned
+ * suppression is inert and the original read stays `[]`.
+ */
+export function suppressPiPackageUpdates(
+	prototype: PackageManagerPrototype = DefaultPackageManager.prototype as PackageManagerPrototype,
+): UpdateSuppression {
+	const marked = prototype as MarkedPrototype;
+	const existing = marked[SUPPRESSION];
+	if (existing) return existing;
+
+	const original = prototype.checkForAvailableUpdates;
+	if (typeof original !== "function") return { check: async () => [], restore: () => {} };
+	const originalCheck = original as unknown as (this: DefaultPackageManager) => Promise<PackageUpdate[]>;
+	const check: PackageUpdateCheck = (manager) => originalCheck.call(manager);
+	const patched: PackageUpdateCheck = async () => [];
+	const restore = (): void => {
+		if (prototype.checkForAvailableUpdates === patched) prototype.checkForAvailableUpdates = original;
+		delete marked[SUPPRESSION];
+	};
+	const suppression: UpdateSuppression = { check, restore };
+	prototype.checkForAvailableUpdates = patched;
+	marked[SUPPRESSION] = suppression;
+	return suppression;
+}

package/extensions/bytefly/update/types.ts

@@ -0,0 +1,15 @@
+/**
+ * The package-update shape Pi's manager returns.
+ *
+ * Pi exports the manager but not its `PackageUpdate` interface, so the type is
+ * derived from the public method. That keeps the extension on the same contract
+ * without reaching into a dist path or restating the fields.
+ */
+
+import type { DefaultPackageManager } from "@earendil-works/pi-coding-agent";
+
+/** One package Pi reports as updateable. */
+export type PackageUpdate = Awaited<ReturnType<DefaultPackageManager["checkForAvailableUpdates"]>>[number];
+
+/** Pi's check, captured before suppression and called with a manager. */
+export type PackageUpdateCheck = (manager: DefaultPackageManager) => Promise<PackageUpdate[]>;

package/extensions/bytefly/working/config.ts

@@ -1,13 +1,12 @@
 /**
- * Tuning for bytefly's live working timer.
+ * Tuning for bytefly's live working line.
  *
- * While Pi's working row is up, the counter is written into the working message
- * Pi renders beside its spinner. Edit this file to change the word or how often
- * the count advances.
+ * While Pi's working row is up, the message is written into the row beside Pi's
+ * spinner. Edit this file to change the words or how often the count advances.
  */
 
 export const WORKING_CONFIG = {
-	/** Word before the count. */
+	/** Word before the count, before the first tool starts. */
 	working: "Working",
 	/** Between the word and the count. */
 	ellipsis: "…",

package/extensions/bytefly/working/format.ts

@@ -1,13 +1,24 @@
 /**
- * Pure text for the live working timer.
+ * Pure text for the live working line.
  *
- * Whole seconds, because the counter advances on a one-second tick: `0s` at the
- * start, `42s`, `1m05s`, `1h02m`. Negative and non-finite input reads as `0s`,
- * so a clock that steps backwards cannot print a negative count.
+ * Before the first tool starts it is a plain count (`Working… 42s`). After that
+ * it names the last top-level tool and how many this run has started, then the
+ * elapsed time (`edit · 3 tools · 42s`). Whole seconds, because the tick
+ * advances once a second; negative and non-finite input reads as `0s`.
  */
 
+import { sanitizeLine, formatToolCount } from "../../../lib/format.ts";
+import { SEPARATORS } from "../../../lib/tui/glyphs.ts";
 import { WORKING_CONFIG } from "./config.ts";
 
+/** What the current run has done so far, for the live line. */
+export interface WorkingRun {
+	/** The last top-level tool started, or `null` before the first one. */
+	readonly tool: string | null;
+	/** Top-level tool calls started in this run. */
+	readonly tools: number;
+}
+
 /** Compact elapsed time in whole seconds: `0s`, `42s`, `1m05s`, `1h02m`. */
 export function formatElapsed(ms: number): string {
 	const total = Number.isFinite(ms) && ms > 0 ? Math.floor(ms / 1000) : 0;
@@ -19,7 +30,13 @@ export function formatElapsed(ms: number): string {
 	return `${seconds}s`;
 }
 
-/** The working-row message for an elapsed time, e.g. `Working… 4s`. */
-export function workingCounter(ms: number): string {
-	return `${WORKING_CONFIG.working}${WORKING_CONFIG.ellipsis} ${formatElapsed(ms)}`;
+/** The working-row message: `Working… 4s` until a tool starts, then the run line. */
+export function workingCounter(ms: number, run?: WorkingRun): string {
+	const elapsed = formatElapsed(ms);
+	const tools = run?.tools ?? 0;
+	const tool = run?.tool ? sanitizeLine(run.tool) : "";
+	if (tools > 0) {
+		return [tool, formatToolCount(tools), elapsed].filter((part) => part !== "").join(SEPARATORS.item);
+	}
+	return `${WORKING_CONFIG.working}${WORKING_CONFIG.ellipsis} ${elapsed}`;
 }

package/extensions/bytefly/working/register.ts

@@ -1,9 +1,11 @@
 /**
- * bytefly's live working timer.
+ * bytefly's live working line.
  *
  * Pi's working row shows a static `Working`, so a long run reads the same as a
  * short one. This surface advances the message once a second while the row is
- * up, and hands it back to Pi when the row comes down.
+ * up, and hands it back to Pi when the row comes down. Once a top-level tool
+ * starts, the message also names that tool and how many this run has started,
+ * turning the row into a live run line (`edit · 3 tools · 12s`).
  *
  * The timer is tied to the row's visibility. The host shows the working
  * indicator in its own `turn_start` handler and clears it at `agent_end`
@@ -12,6 +14,11 @@
  * one run do not restart it: the host leaves the same indicator up across
  * turns, and `start` is a no-op while it is counting.
  *
+ * A nested tool call (one carrying `parentToolCallId`, such as a codemode
+ * script's inner call) is not counted and does not take over the line, so the
+ * number matches the tool blocks the transcript shows. The tool events repaint
+ * the row immediately; the one-second tick is still the only timer.
+ *
  * Compaction and auto-retry also replace the row, but both run outside this
  * window (`auto_retry_start` follows `agent_end`; the before-settle compaction
  * runs after it), and neither is an extension event, so there is nothing to
@@ -49,6 +56,17 @@ export function registerWorkingTimer(pi: ExtensionAPI, deps: WorkingDeps = {}):
 	let startedAt = 0;
 	// A boolean, not `startedAt === 0`: an injected clock is allowed to start at 0.
 	let active = false;
+	// The last top-level tool and how many this run has started. Reset with the run.
+	let tool: string | null = null;
+	let tools = 0;
+
+	/** The current row text, from the run state and the elapsed time. */
+	const message = (): string => workingCounter(now() - startedAt, { tool, tools });
+
+	/** Repaint an active row now, so a tool start does not wait for the next tick. */
+	const refresh = (ctx: ExtensionContext): void => {
+		if (active) ctx.ui.setWorkingMessage(message());
+	};
 
 	/** Stop the tick and hand the working message back to Pi. Idempotent. */
 	const stop = (ctx: ExtensionContext): void => {
@@ -56,6 +74,8 @@ export function registerWorkingTimer(pi: ExtensionAPI, deps: WorkingDeps = {}):
 		cancel = undefined;
 		if (!active) return;
 		active = false;
+		tool = null;
+		tools = 0;
 		ctx.ui.setWorkingMessage(undefined);
 	};
 
@@ -64,8 +84,10 @@ export function registerWorkingTimer(pi: ExtensionAPI, deps: WorkingDeps = {}):
 		if (active) return;
 		startedAt = now();
 		active = true;
+		tool = null;
+		tools = 0;
 		const tick = (): void => {
-			ctx.ui.setWorkingMessage(workingCounter(now() - startedAt));
+			ctx.ui.setWorkingMessage(message());
 		};
 		tick();
 		cancel = schedule(tick, WORKING_CONFIG.intervalMs);
@@ -78,6 +100,15 @@ export function registerWorkingTimer(pi: ExtensionAPI, deps: WorkingDeps = {}):
 		start(ctx);
 	});
 
+	// A nested tool is an implementation detail of its parent run, not a
+	// transcript block, so it neither counts nor takes over the line.
+	pi.on("tool_execution_start", (event, ctx) => {
+		if (ctx.mode !== "tui" || !active || event.parentToolCallId) return;
+		tool = event.toolName;
+		tools += 1;
+		refresh(ctx);
+	});
+
 	// The host clears the working indicator at `agent_end`.
 	pi.on("agent_end", (_event, ctx) => {
 		if (ctx.mode !== "tui") return;