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

package/extensions/bytefly/separator/register.ts

@@ -4,11 +4,15 @@
  * Pi has no built-in turn separator. On every fully settled agent run
  * (`agent_settled`, one per user turn) this appends an inert custom entry that
  * is excluded from LLM context, and a registered entry renderer draws it as a
- * centered `╌╌╌ turn N ╌╌╌` rule in the interactive transcript.
+ * centered `╌╌╌ turn N ╌╌╌` rule in the interactive transcript. The entry also
+ * carries the run's receipt — duration, top-level tool count, failed tools, and
+ * whether the user aborted it — so the rule can read as a flight log.
  *
  * `agent_settled` is deliberate: `turn_end` fires once per assistant message,
  * so tool-calling rounds would each get a line, while a settled run is exactly
- * one user turn.
+ * one user turn. The run's first `agent_start` opens the receipt and later
+ * starts (a retry or a continuation) stay in it, so the duration covers the
+ * whole settled run rather than one attempt.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -17,6 +21,12 @@ import { SeparatorComponent } from "./component.ts";
 import { CONFIG } from "./config.ts";
 import type { TurnSeparatorData } from "./types.ts";
 
+/** Host seams, injected by tests so the duration is deterministic. */
+export interface SeparatorDeps {
+	/** The clock the duration is read from. */
+	now?: () => number;
+}
+
 /** Count separators already on the branch, so numbering survives resume and fork. */
 function countSeparators(entries: readonly { type: string; customType?: string }[]): number {
 	let count = 0;
@@ -27,17 +37,66 @@ function countSeparators(entries: readonly { type: string; customType?: string }
 }
 
 /** Register the separator renderer and append one on every settled turn. */
-export function registerTurnSeparator(pi: ExtensionAPI, pad: PadSource = createPadStore()): void {
+export function registerTurnSeparator(
+	pi: ExtensionAPI,
+	pad: PadSource = createPadStore(),
+	deps: SeparatorDeps = {},
+): void {
+	const now = deps.now ?? (() => Date.now());
+	// The current run's receipt. `startedAt` is the first `agent_start`; the
+	// counters span every top-level tool in the settled run.
+	let startedAt: number | undefined;
+	let tools = 0;
+	let failures = 0;
+
+	const reset = (): void => {
+		startedAt = undefined;
+		tools = 0;
+		failures = 0;
+	};
+
 	pi.registerEntryRenderer<TurnSeparatorData>(CONFIG.customType, (entry, _options, theme) => {
-		const turn = entry.data?.turn;
-		if (typeof turn !== "number" || !Number.isFinite(turn)) return undefined;
-		return new SeparatorComponent(turn, theme, pad.resolve());
+		const data = entry.data;
+		if (!data || typeof data.turn !== "number" || !Number.isFinite(data.turn)) return undefined;
+		return new SeparatorComponent(data, theme, pad.resolve());
+	});
+
+	pi.on("agent_start", (_event, ctx) => {
+		if (ctx.mode !== "tui" || startedAt !== undefined) return;
+		startedAt = now();
+		tools = 0;
+		failures = 0;
 	});
 
-	pi.on("agent_settled", (_event, ctx) => {
+	// A nested tool is an implementation detail of its parent, not a transcript
+	// block, so it neither counts nor contributes a failure.
+	pi.on("tool_execution_start", (event) => {
+		if (startedAt === undefined || event.parentToolCallId) return;
+		tools += 1;
+	});
+
+	pi.on("tool_execution_end", (event) => {
+		if (startedAt === undefined || event.parentToolCallId || !event.isError) return;
+		failures += 1;
+	});
+
+	pi.on("agent_settled", (event, ctx) => {
 		// The transcript is interactive-only; keep RPC/JSON/print sessions clean.
-		if (ctx.mode !== "tui") return;
+		if (ctx.mode !== "tui") {
+			reset();
+			return;
+		}
 		const turn = countSeparators(ctx.sessionManager.getBranch()) + 1;
-		pi.appendEntry<TurnSeparatorData>(CONFIG.customType, { turn });
+		const data: TurnSeparatorData = { turn };
+		if (startedAt !== undefined) {
+			data.durationMs = Math.max(0, now() - startedAt);
+			if (tools > 0) data.tools = tools;
+			if (failures > 0) data.failures = failures;
+		}
+		if (event.aborted) data.aborted = true;
+		pi.appendEntry<TurnSeparatorData>(CONFIG.customType, data);
+		reset();
 	});
+
+	pi.on("session_shutdown", () => reset());
 }

package/extensions/bytefly/separator/types.ts

@@ -9,4 +9,12 @@
 export interface TurnSeparatorData {
 	/** 1-based index of the completed user turn this separator follows. */
 	turn: number;
+	/** From the run's first `agent_start` to `agent_settled`, in milliseconds. */
+	durationMs?: number;
+	/** Top-level tool calls the run started. */
+	tools?: number;
+	/** Top-level tool calls that ended in error. */
+	failures?: number;
+	/** Whether the run ended because the user aborted it. */
+	aborted?: boolean;
 }

package/extensions/bytefly/update/cache.ts

@@ -1,34 +1,42 @@
 /**
- * The published-version answer, cached on disk with the time it was read.
+ * The package-update snapshot, cached on disk with the time it was read.
  *
- * The check already fires once per session, which leaves two gaps: a session open
- * for days never re-reads npm, and every new session pays for a request it made
- * minutes earlier. A timestamp is what fixes the second, so the cache lives in the
- * agent directory rather than in memory — one entry, one window, shared by every
- * session that starts inside it.
+ * The 24-hour window 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 Pi's npm/git checks, and `/bytefly update` re-runs them on demand.
+ * The entry is keyed by the working directory and the effective package sources,
+ * so a project switch or an install/removal invalidates it instead of showing
+ * another project's list.
  *
- * A cache can only ever be a miss. An absent, unreadable, or wrong-typed file
- * reads as `undefined` and the caller fetches; nothing here throws, because a
- * stale file must never become a session error.
+ * A cache can only ever be a miss. An absent, unreadable, old-schema, or
+ * mistyped file reads as `undefined` and the caller fetches; nothing here
+ * throws, because a stale file must never become a session error.
  */
 
+import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import type { PackageSource } from "@earendil-works/pi-coding-agent";
 import { writeConfigFile } from "../../../lib/config.ts";
+import type { PackageUpdate } from "./types.ts";
 import { parseVersion } from "./version.ts";
 
 /** The file name under `<agentDir>/bytefly/`. */
 export const UPDATE_CACHE_FILE = "update.json";
 
-/** How long a cached answer is reused before the next session re-reads npm. */
+/** How long a cached snapshot is reused before the next session re-reads. */
 export const UPDATE_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 
-/** One cached answer: the newest published version and when it was read. */
+/** One cached snapshot: Pi's list, this package's version, and when it was read. */
 export interface UpdateCacheEntry {
-	/** The version npm's `latest` tag pointed at. */
-	latest: string;
-	/** Epoch milliseconds of the read that produced `latest`. */
+	/** Identity of the cwd plus the effective package sources. */
+	key: string;
+	/** Epoch milliseconds of the read that produced this snapshot. */
 	checkedAt: number;
+	/** Every package Pi reported as updateable. */
+	updates: PackageUpdate[];
+	/** This package's new version, when it is one of the updates. */
+	latest?: string;
 }
 
 /** Where the cache lives for an agent directory. */
@@ -36,15 +44,41 @@ export function updateCachePath(agentDir: string): string {
 	return join(agentDir, "bytefly", UPDATE_CACHE_FILE);
 }
 
-/** Read the cache; a missing, corrupt, or mistyped entry is `undefined`. */
+/** Stable identity for the settings a snapshot was read under. */
+export function updateCacheKey(cwd: string, packages: readonly PackageSource[] | undefined): string {
+	return createHash("sha256")
+		.update(JSON.stringify({ cwd, packages: packages ?? [] }))
+		.digest("hex");
+}
+
+/** Whether a value has the fields Pi's package update carries. */
+function isPackageUpdate(value: unknown): value is PackageUpdate {
+	if (!value || typeof value !== "object") return false;
+	const update = value as Partial<PackageUpdate>;
+	return (
+		typeof update.source === "string" &&
+		typeof update.displayName === "string" &&
+		(update.type === "npm" || update.type === "git") &&
+		(update.scope === "user" || update.scope === "project")
+	);
+}
+
+/** Read the cache; a missing, corrupt, old-schema, or mistyped entry is `undefined`. */
 export function readUpdateCache(path: string): UpdateCacheEntry | undefined {
 	try {
 		const raw = JSON.parse(readFileSync(path, "utf-8")) as Record<string, unknown> | undefined;
 		if (!raw || typeof raw !== "object") return undefined;
-		const latest = typeof raw.latest === "string" ? raw.latest.trim() : "";
+		const key = typeof raw.key === "string" ? raw.key.trim() : "";
 		const checkedAt = typeof raw.checkedAt === "number" && Number.isFinite(raw.checkedAt) ? raw.checkedAt : 0;
-		if (!parseVersion(latest) || checkedAt <= 0) return undefined;
-		return { latest, checkedAt };
+		const updates = Array.isArray(raw.updates) ? raw.updates : undefined;
+		if (!key || checkedAt <= 0 || !updates || !updates.every(isPackageUpdate)) return undefined;
+		const latest = typeof raw.latest === "string" ? raw.latest.trim() : "";
+		return {
+			key,
+			checkedAt,
+			updates,
+			...(parseVersion(latest) ? { latest } : {}),
+		};
 	} catch {
 		return undefined;
 	}
@@ -55,7 +89,12 @@ export function readUpdateCache(path: string): UpdateCacheEntry | undefined {
  * treats a throw as a miss: a read-only agent directory must not break a session.
  */
 export function writeUpdateCache(path: string, entry: UpdateCacheEntry): void {
-	writeConfigFile(path, { latest: entry.latest, checkedAt: entry.checkedAt });
+	writeConfigFile(path, {
+		key: entry.key,
+		checkedAt: entry.checkedAt,
+		updates: entry.updates,
+		...(entry.latest ? { latest: entry.latest } : {}),
+	});
 }
 
 /**

package/extensions/bytefly/update/check.ts

@@ -10,6 +10,8 @@
  * never sees an error from a check nobody asked for.
  */
 
+import { DefaultPackageManager, getAgentDir, SettingsManager } from "@earendil-works/pi-coding-agent";
+import type { PackageUpdate, PackageUpdateCheck } from "./types.ts";
 import { parseVersion } from "./version.ts";
 
 /** The published document holding the version npm's `latest` tag points at. */
@@ -37,6 +39,39 @@ export interface UpdateCheckDeps {
 	timeoutMs?: number;
 }
 
+/** What the package-manager read needs. */
+export interface AvailableUpdatesDeps {
+	/** Session working directory. */
+	cwd: string;
+	/** Pi agent directory; defaults to `getAgentDir()`. */
+	agentDir?: string;
+	/** Whether project-local packages may be read. */
+	projectTrusted: boolean;
+	/** The real check captured before suppression; defaults to the manager method. */
+	checkForAvailableUpdates?: PackageUpdateCheck;
+}
+
+/**
+ * Every package Pi would update, or `undefined` when the check cannot run.
+ *
+ * The distinction is load-bearing: an empty list is a real answer ("everything is
+ * current") that the caller caches for a day, while a failed read must leave the
+ * previous snapshot and the header marker alone.
+ */
+export async function fetchAvailableUpdates(deps: AvailableUpdatesDeps): Promise<PackageUpdate[] | undefined> {
+	try {
+		const agentDir = deps.agentDir ?? getAgentDir();
+		const settingsManager = SettingsManager.create(deps.cwd, agentDir, {
+			projectTrusted: deps.projectTrusted,
+		});
+		const manager = new DefaultPackageManager({ cwd: deps.cwd, agentDir, settingsManager });
+		const check = deps.checkForAvailableUpdates ?? ((current) => current.checkForAvailableUpdates());
+		return await check(manager);
+	} catch {
+		return undefined;
+	}
+}
+
 /** The latest published version, or `undefined` when it cannot be read. */
 export async function fetchLatestVersion(deps: UpdateCheckDeps = {}): Promise<string | undefined> {
 	const request: FetchLike = deps.fetch ?? ((url, init) => globalThis.fetch(url, init));

package/extensions/bytefly/update/format.ts

@@ -1,25 +1,27 @@
 /**
- * Wording for the update check: the header marker, the one transcript notice, and
- * the answer an explicit re-check prints.
+ * Wording for the update surface: the header marker, the one transcript notice,
+ * and the answer an explicit re-check prints.
  *
- * All three read the same two facts — the version this session loaded and the
- * version the registry publishes — and none adds a third. The marker is the
- * shortest honest form (`↑0.12.0`); the notice names the command and the release
- * URL as text, because the notice renderer has no link support; and the re-check
- * says what it just found, including the two cases it cannot answer (offline, and
- * a registry it could not read).
+ * Pi's package manager decides which configured packages are behind. The marker
+ * is still only this package's newest version (`↑0.12.0`); the notice names every
+ * package Pi reported and, for this package, the version arrow and release URL
+ * the notice renderer can print as text.
  */
 
 import pkg from "../../../package.json";
 import { noticeMessage, type NoticeMessage } from "../../../lib/notice.ts";
 import { GLYPHS } from "../../../lib/tui/glyphs.ts";
 import type { UpdateOutcome } from "./state.ts";
+import type { PackageUpdate } from "./types.ts";
 
-/** The header marker: an up arrow and the newest version, e.g. `↑0.12.0`. */
+/** The header marker: an up arrow and this package's newest version. */
 export function updateMarker(latest: string): string {
 	return `${GLYPHS.update}${latest}`;
 }
 
+/** The command that resolves every row in the notice. */
+export const UPDATE_COMMAND = "pi update --extensions";
+
 /**
  * The release page for a version, or `undefined` when this checkout does not name
  * a GitHub repository. Derived from `package.json` so a rename cannot leave a dead
@@ -32,35 +34,72 @@ export function releaseUrl(version: string): string | undefined {
 	return `${base}/releases/tag/v${version}`;
 }
 
-/** The single notice a session posts when a newer version is published. */
-export function updateNotice(current: string, latest: string): NoticeMessage {
-	const release = releaseUrl(latest);
-	const command = "pi update --extensions";
+/** Whether a row is this package, whose version the header and notice show. */
+export function isOwnPackage(update: PackageUpdate): boolean {
+	return update.type === "npm" && update.displayName === pkg.name;
+}
+
+/** The scope word Pi's package update carries. */
+function scopeLabel(update: PackageUpdate): string {
+	return update.scope === "project" ? "project" : "global";
+}
+
+/** One package row: the version arrow for this package, the scope for the rest. */
+function packageRow(
+	update: PackageUpdate,
+	current: string,
+	ownLatest?: string,
+): {
+	label: string;
+	detail: string;
+	severity: "info";
+} {
+	const detail = isOwnPackage(update) && ownLatest ? `v${current} → v${ownLatest}` : scopeLabel(update);
+	return { label: update.displayName, detail, severity: "info" };
+}
+
+/** The headline shared by the notice and the re-check answer. */
+function headline(count: number): string {
+	return count === 1 ? "1 package update available" : `${count} package updates available`;
+}
+
+/** The headline and the package names, the sentence both answers open with. */
+function namesLine(updates: readonly PackageUpdate[]): string {
+	return `${headline(updates.length)}: ${updates.map((update) => update.displayName).join(", ")}.`;
+}
+
+/** The release URL for this package's new version, when it is known. */
+function ownRelease(ownLatest?: string): string | undefined {
+	return ownLatest ? releaseUrl(ownLatest) : undefined;
+}
+
+/** The single notice a session posts when Pi reports package updates. */
+export function updateNotice(updates: readonly PackageUpdate[], current: string, ownLatest?: string): NoticeMessage {
+	const own = updates.find(isOwnPackage);
+	const release = own ? ownRelease(ownLatest) : undefined;
+	const parts = [namesLine(updates)];
+	if (own && ownLatest) parts.push(`${pkg.name} v${current} → v${ownLatest}.`);
+	parts.push(`Run \`${UPDATE_COMMAND}\` to update.`);
+	if (release) parts.push(`Release notes: ${release}`);
 	return noticeMessage({
-		content:
-			`bytefly ${latest} is available (current ${current}). Run \`${command}\` to update.` +
-			(release ? ` Release notes: ${release}` : ""),
+		content: parts.join(" "),
 		details: {
 			source: "bytefly",
-			title: `${latest} is available`,
+			title: headline(updates.length),
 			severity: "info",
-			items: release
-				? [
-						{ label: "current", detail: `v${current}` },
-						{ label: "update", detail: command },
-						{ label: "release", detail: release },
-					]
-				: [
-						{ label: "current", detail: `v${current}` },
-						{ label: "update", detail: command },
-					],
+			items: [
+				...updates.map((update) => packageRow(update, current, ownLatest)),
+				{ label: "update", detail: UPDATE_COMMAND },
+				...(release ? [{ label: "release", detail: release }] : []),
+			],
 		},
 	});
 }
 
 /**
  * What `/bytefly update` prints. The background check is silent because nobody
- * asked; here someone did, so a skip and a failed read are answers too.
+ * asked; here someone did, so a skip, a failure, and an up-to-date answer are
+ * answers too.
  */
 export function updateOutcomeText(
 	outcome: UpdateOutcome,
@@ -71,17 +110,19 @@ export function updateOutcomeText(
 			return { text: "bytefly: the update check was skipped (PI_OFFLINE is set).", severity: "info" };
 		case "failed":
 			return {
-				text: "bytefly: could not read the published version — check the network and try again.",
+				text: "bytefly: could not check package updates — check the network and try again.",
 				severity: "warning",
 			};
 		case "current":
-			return { text: `bytefly: up to date — v${outcome.latest} is the newest published version.`, severity: "info" };
+			return { text: "bytefly: up to date — no configured package has an update.", severity: "info" };
 		case "available": {
-			const release = releaseUrl(outcome.latest);
-			return {
-				text: `bytefly: v${outcome.latest} is available (current ${current}).${release ? ` ${release}` : ""}`,
-				severity: "info",
-			};
+			const own = outcome.updates.some(isOwnPackage);
+			const release = own ? ownRelease(outcome.ownLatest) : undefined;
+			const parts = [`bytefly: ${namesLine(outcome.updates)}`];
+			if (own && outcome.ownLatest) parts.push(`This package is v${current} → v${outcome.ownLatest}.`);
+			parts.push(`Run ${UPDATE_COMMAND}.`);
+			if (release) parts.push(`Release notes: ${release}`);
+			return { text: parts.join(" "), severity: "info" };
 		}
 	}
 }