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

package/extensions/bytefly/picker/discovery.ts

@@ -46,8 +46,6 @@ export function createSettingsStore(manager: SettingsManager): SettingsStore {
 		setProjectSkillPaths: (paths) => manager.setProjectSkillPaths(paths),
 		setProjectPackages: (packages) => manager.setProjectPackages(packages),
 		setQuietStartup: (quiet) => manager.setQuietStartup(quiet),
-		setOutputPad: (padding) => manager.setOutputPad(padding),
-		setShowHardwareCursor: (enabled) => manager.setShowHardwareCursor(enabled),
 		setTheme: (theme) => manager.setTheme(theme),
 		isProjectTrusted: () => manager.isProjectTrusted(),
 		flush: () => manager.flush(),

package/extensions/bytefly/picker/types.ts

@@ -47,8 +47,6 @@ export interface SettingsStore {
 	setProjectPackages(packages: PackageSource[]): void;
 	/** App preferences are written to the personal settings file. */
 	setQuietStartup(quiet: QuietStartup): void;
-	setOutputPad(padding: 0 | 1): void;
-	setShowHardwareCursor(enabled: boolean): void;
 	/** Pi's theme setting is a personal-file preference. */
 	setTheme(theme: string): void;
 	isProjectTrusted(): boolean;

package/extensions/bytefly/update/check.ts

@@ -11,6 +11,7 @@
  */
 
 import { DefaultPackageManager, getAgentDir, SettingsManager } from "@earendil-works/pi-coding-agent";
+import type { ProgressEvent } from "@earendil-works/pi-coding-agent";
 import type { PackageUpdate, PackageUpdateCheck } from "./types.ts";
 import { parseVersion } from "./version.ts";
 
@@ -51,6 +52,44 @@ export interface AvailableUpdatesDeps {
 	checkForAvailableUpdates?: PackageUpdateCheck;
 }
 
+/** What applying an update needs: the same manager the check builds, plus a source. */
+export interface ApplyUpdatesDeps {
+	/** Session working directory. */
+	cwd: string;
+	/** Pi agent directory; defaults to `getAgentDir()`. */
+	agentDir?: string;
+	/** Whether project-local packages may be read. */
+	projectTrusted: boolean;
+	/** One source to update; every configured package when omitted. */
+	source?: string;
+	/** Called as Pi's manager reports progress, so a surface can show one line. */
+	onProgress?: (message: string) => void;
+}
+
+/**
+ * Apply the update through Pi's own package manager.
+ *
+ * This is deliberately not a shell: `pi update --extensions` is a command a human
+ * types, while `update()` is the manager that owns the install root, the settings
+ * that name each package, and the npm command a project configured. It resolves
+ * nothing interactively, honors `PI_OFFLINE` by returning early, and skips a
+ * pinned npm version — so the caller's job is the confirmation and the report, not
+ * the mechanics. It throws when a named source matches no configured package or
+ * when the install command fails, and returns nothing on success.
+ */
+export async function applyUpdates(deps: ApplyUpdatesDeps): Promise<void> {
+	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 report = deps.onProgress;
+	if (report) {
+		manager.setProgressCallback((event: ProgressEvent) => {
+			if (event.message) report(event.message);
+		});
+	}
+	await manager.update(deps.source);
+}
+
 /**
  * Every package Pi would update, or `undefined` when the check cannot run.
  *

package/extensions/bytefly/update/format.ts

@@ -174,6 +174,21 @@ export function updateOutcomeText(
 			};
 		case "current":
 			return { text: "bytefly: up to date — no configured package has an update.", severity: "info" };
+		case "update-failed":
+			return {
+				text: `bytefly: the update did not finish — ${sanitizeLine(outcome.reason)}`,
+				severity: "warning",
+			};
+		case "updated":
+			return outcome.pending
+				? {
+						text: `bytefly: the update ran, but a package is still behind — run ${UPDATE_COMMAND} or /bytefly update.`,
+						severity: "warning",
+					}
+				: {
+						text: "bytefly: every configured package is updated — reload to use the new version.",
+						severity: "info",
+					};
 		case "available": {
 			const own = outcome.updates.some(isOwnPackage);
 			const release = own ? ownRelease(outcome.ownLatest) : undefined;

package/extensions/bytefly/update/register.ts

@@ -17,6 +17,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import pkg from "../../../package.json";
+import { messageOf } from "../../../lib/errors.ts";
 import { isOffline } from "../../../lib/env.ts";
 import {
 	isFresh,
@@ -26,7 +27,7 @@ import {
 	writeUpdateCache,
 	type UpdateCacheEntry,
 } from "./cache.ts";
-import { fetchAvailableUpdates, fetchLatestVersion } from "./check.ts";
+import { applyUpdates, fetchAvailableUpdates, fetchLatestVersion } from "./check.ts";
 import { isOwnPackage, updateNotice } from "./format.ts";
 import { paintLatest, type UpdateOutcome, type UpdateSource } from "./state.ts";
 import { suppressPiPackageUpdates, type UpdateSuppression } from "./suppress.ts";
@@ -45,6 +46,8 @@ export interface UpdateCache {
 export interface UpdateHandle {
 	/** Read the package list now, ignoring the cache window. Never throws. */
 	recheck(): Promise<UpdateOutcome>;
+	/** Apply the update, then re-read it. Never throws. */
+	apply(): Promise<UpdateOutcome>;
 }
 
 /** Test seams; production uses Pi's package manager, its cache, and the agent dir. */
@@ -53,6 +56,8 @@ export interface UpdateDeps {
 	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 package-manager update; defaults to Pi's own manager. */
+	applyUpdates?: (ctx: ExtensionContext) => Promise<void>;
 	/** Replace the `PI_OFFLINE` check. */
 	isOffline?: () => boolean;
 	/** Replace the disk cache. */
@@ -94,6 +99,16 @@ export function registerUpdate(pi: ExtensionAPI, updates: UpdateSource, deps: Up
 				checkForAvailableUpdates: check,
 			}));
 	const readLatest = deps.fetchLatest ?? (() => fetchLatestVersion());
+	const applyUpdate =
+		deps.applyUpdates ??
+		((ctx: ExtensionContext) =>
+			applyUpdates({
+				cwd: ctx.cwd,
+				agentDir: getAgentDir(),
+				projectTrusted: ctx.isProjectTrusted(),
+				// Pi's manager reports one line per source; a slow install is otherwise silent.
+				onProgress: (message) => ctx.ui.notify(message, "info"),
+			}));
 	const offline = deps.isOffline ?? isOffline;
 	const cache = deps.cache ?? diskCache();
 	const now = deps.now ?? Date.now;
@@ -155,6 +170,22 @@ export function registerUpdate(pi: ExtensionAPI, updates: UpdateSource, deps: Up
 		return latest && isNewerVersion(latest, pkg.version) ? latest : undefined;
 	};
 
+	/**
+	 * One snapshot from a package list: this package's version label, the cache key,
+	 * and the clock. The background check and the panel's recheck differ only in what
+	 * they do with a snapshot, so the assembly lives here once instead of being
+	 * copied wherever something new needs to record a reading.
+	 */
+	const buildSnapshot = async (ctx: ExtensionContext, list: PackageUpdate[]): Promise<UpdateCacheEntry> => {
+		const latest = await resolveOwnLatest(list.find(isOwnPackage));
+		return {
+			key: keyFor(ctx),
+			checkedAt: now(),
+			updates: list,
+			...(latest ? { latest } : {}),
+		};
+	};
+
 	const check = async (ctx: ExtensionContext, token: number): Promise<void> => {
 		try {
 			const list = await readUpdates(ctx, activeCheck());
@@ -163,14 +194,8 @@ export function registerUpdate(pi: ExtensionAPI, updates: UpdateSource, deps: Up
 			// 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));
+			const entry = await buildSnapshot(ctx, list);
 			if (token !== generation) return;
-			const entry: UpdateCacheEntry = {
-				key: keyFor(ctx),
-				checkedAt: now(),
-				updates: list,
-				...(latest ? { latest } : {}),
-			};
 			writeCache(entry);
 			record(entry);
 		} catch {
@@ -210,31 +235,45 @@ export function registerUpdate(pi: ExtensionAPI, updates: UpdateSource, deps: Up
 		context = undefined;
 	});
 
-	return {
-		async recheck() {
-			if (offline()) return { kind: "offline" };
-			if (!context) return { kind: "failed" };
-			let list: PackageUpdate[];
-			try {
-				const found = await readUpdates(context, activeCheck());
-				if (found === undefined) return { kind: "failed" };
-				list = found;
-			} catch {
-				return { kind: "failed" };
-			}
-			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.
-			paintLatest(updates, latest, deps.onUpdate);
-			return list.length > 0
-				? { kind: "available", updates: list, ...(latest ? { ownLatest: latest } : {}) }
-				: { kind: "current" };
-		},
+	/** Re-read the published state on demand; `/bytefly update` prints the answer. */
+	const recheck = async (): Promise<UpdateOutcome> => {
+		if (offline()) return { kind: "offline" };
+		if (!context) return { kind: "failed" };
+		let list: PackageUpdate[];
+		try {
+			const found = await readUpdates(context, activeCheck());
+			if (found === undefined) return { kind: "failed" };
+			list = found;
+		} catch {
+			return { kind: "failed" };
+		}
+		const entry = await buildSnapshot(context, list);
+		writeCache(entry);
+		// The caller prints the answer, so this path never posts a notice.
+		const ownLatest = ownLatestOf(entry);
+		paintLatest(updates, ownLatest, deps.onUpdate);
+		return list.length > 0
+			? { kind: "available", updates: list, ...(ownLatest ? { ownLatest } : {}) }
+			: { kind: "current" };
 	};
+
+	/**
+	 * Apply the update through Pi's manager, then re-read it: the snapshot on disk and
+	 * on screen described the version that was just replaced, so leaving it would keep
+	 * a marker for code this session no longer runs. `pending` is the manager reporting
+	 * success over a package that is still behind, which is worth saying out loud.
+	 */
+	const apply = async (): Promise<UpdateOutcome> => {
+		if (offline()) return { kind: "offline" };
+		if (!context) return { kind: "failed" };
+		try {
+			await applyUpdate(context);
+		} catch (error) {
+			return { kind: "update-failed", reason: messageOf(error) };
+		}
+		const after = await recheck();
+		return { kind: "updated", pending: after.kind === "available" };
+	};
+
+	return { recheck, apply };
 }

package/extensions/bytefly/update/state.ts

@@ -20,13 +20,16 @@ export interface UpdateSource {
 }
 
 /**
- * What one explicit re-check found. The background check reports nothing — nobody
- * asked — so this vocabulary exists only for `/bytefly update`, where a failure or
- * a skip is an answer rather than silence.
+ * What one explicit update reported. The background check reports nothing — nobody
+ * asked — so this vocabulary exists only for `/bytefly update` and
+ * `/bytefly upgrade`, where a failure, a skip, or a refusal is an answer rather
+ * than silence.
  */
 export type UpdateOutcome =
 	| { kind: "offline" }
 	| { kind: "failed" }
+	| { kind: "update-failed"; reason: string }
+	| { kind: "updated"; pending: boolean }
 	| { kind: "current" }
 	| { kind: "available"; updates: readonly PackageUpdate[]; ownLatest?: string };
 

package/extensions/check/commands.ts

@@ -10,6 +10,7 @@
 
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { resolveEffectiveCwd } from "../../lib/env.ts";
+import { planModeRefusal } from "../../lib/plan-entry.ts";
 import { isPlanModeEnabled } from "../../lib/plan-state.ts";
 import { withRailsSuppressed } from "../../lib/rails.ts";
 import { formatCheckReport, formatCheckSummary } from "./format.ts";
@@ -107,7 +108,7 @@ export function registerCheckCommand(pi: ExtensionAPI, runtime: CheckRuntime): v
 		},
 		handler: async (args, ctx) => {
 			if (isPlanModeEnabled(ctx.sessionManager.getBranch())) {
-				ctx.ui.notify("Plan mode is read-only. Approve the plan before running checks.", "warning");
+				ctx.ui.notify(planModeRefusal("running checks"), "warning");
 				return;
 			}
 			const target = parseTarget(args, ctx);

package/extensions/context/tui.ts

@@ -203,7 +203,7 @@ export class ContextComponent implements Component {
 			lines.push("", `  ${paint(this.theme, "label", "Largest messages")}`);
 			for (const block of report.largest) {
 				const tokens = formatTokens(block.tokens).padStart(6);
-				const role = padCell(block.role, 11);
+				const role = padCell(block.role, 12);
 				const candidate = `    ${paint(this.theme, "meta", tokens)}  ${paint(this.theme, "label", role)}${block.label}`;
 				lines.push(truncateToWidth(candidate, width));
 			}

package/extensions/file-browse/{config.ts → config/config.ts}

@@ -7,7 +7,7 @@
  */
 
 import { randomInt } from "node:crypto";
-import { asBoolean, clampInteger, loadConfigSection } from "../../lib/config.ts";
+import { asBoolean, clampInteger, loadConfigSection } from "../../../lib/config.ts";
 
 export interface ServeConfig {
 	/** TCP port on 127.0.0.1; `0` picks one random port fixed for the session, a positive value pins it. */

package/extensions/file-browse/files/classify.ts

@@ -0,0 +1,136 @@
+/**
+ * What a file's kind is, from its name and — for an extensionless one — a byte sample.
+ *
+ * Every surface that names a kind (the listing's rows, the tree, a preview's routing) asks
+ * here, so "is this an image" has one answer.
+ */
+
+import { basename, extname } from "node:path";
+
+export type EntryKind = "directory" | "text" | "image" | "binary";
+
+/** Image extension (no dot) to MIME type; the single source for image classification. */
+const IMAGE_MIME: Record<string, string> = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml",
+	bmp: "image/bmp",
+	ico: "image/x-icon",
+	avif: "image/avif",
+};
+
+/** Image extensions without a leading dot. */
+export const IMAGE_EXTENSIONS: ReadonlySet<string> = new Set(Object.keys(IMAGE_MIME));
+
+const MARKDOWN_EXTS = new Set([".md", ".markdown", ".mdown", ".mkd", ".mkdn"]);
+const TEXT_EXTS = new Set([
+	".txt",
+	".md",
+	".markdown",
+	".rst",
+	".adoc",
+	".org",
+	".log",
+	".json",
+	".jsonc",
+	".json5",
+	".yaml",
+	".yml",
+	".toml",
+	".ini",
+	".cfg",
+	".conf",
+	".xml",
+	".csv",
+	".tsv",
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".py",
+	".go",
+	".rs",
+	".java",
+	".c",
+	".h",
+	".cc",
+	".cpp",
+	".hpp",
+	".cs",
+	".rb",
+	".php",
+	".sh",
+	".bash",
+	".zsh",
+	".ps1",
+	".swift",
+	".kt",
+	".kts",
+	".scala",
+	".lua",
+	".r",
+	".pl",
+	".sql",
+	".css",
+	".scss",
+	".sass",
+	".less",
+	".html",
+	".htm",
+	".vue",
+	".svelte",
+	".astro",
+]);
+const TEXT_NAMES = new Set([
+	"license",
+	"licence",
+	"makefile",
+	"dockerfile",
+	"readme",
+	"changelog",
+	"authors",
+	"notice",
+]);
+
+export function isImageName(name: string): boolean {
+	return IMAGE_EXTENSIONS.has(extname(name).slice(1).toLowerCase());
+}
+
+/** Whether the name has a Markdown extension. */
+export function isMarkdownName(name: string): boolean {
+	return MARKDOWN_EXTS.has(extname(name).toLowerCase());
+}
+
+/** Extension-based classification for listings (no file contents read). */
+export function classifyByName(name: string): EntryKind {
+	const ext = extname(name).toLowerCase();
+	if (IMAGE_EXTENSIONS.has(ext.slice(1))) return "image";
+	if (TEXT_EXTS.has(ext)) return "text";
+	const lower = basename(name).toLowerCase();
+	if (TEXT_NAMES.has(lower)) return "text";
+	if (!ext && name.startsWith(".")) return "text";
+	return "binary";
+}
+
+/** True when the sample looks like binary data (NUL or many control bytes). */
+export function isProbablyText(sample: Buffer): boolean {
+	if (sample.length === 0) return true;
+	if (sample.includes(0)) return false;
+	let suspicious = 0;
+	for (const byte of sample) {
+		if (byte === 9 || byte === 10 || byte === 13 || byte === 12 || byte === 8) continue;
+		if (byte < 32 || byte === 127) suspicious++;
+	}
+	return suspicious / sample.length < 0.3;
+}
+
+/** MIME type for a name; text is always served as plain text. */
+export function contentTypeFor(name: string): string {
+	const ext = extname(name).slice(1).toLowerCase();
+	return IMAGE_MIME[ext] ?? "application/octet-stream";
+}

package/extensions/file-browse/files/files.ts

@@ -0,0 +1,12 @@
+/**
+ * Filesystem reads for the browse extension: classification, listing, tree, and index.
+ *
+ * Four jobs that a caller wants as one surface, so they are four modules behind this
+ * barrel rather than one 551-line module named after none of them. All paths are absolute
+ * and already vetted by `paths.ts`; nothing here touches the raw request URL.
+ */
+
+export * from "./classify.ts";
+export * from "./index.ts";
+export * from "./list.ts";
+export * from "./tree.ts";

package/extensions/file-browse/files/index.ts

@@ -0,0 +1,90 @@
+/**
+ * The quick-open index: every file path under the root, to `limit`, for the palette.
+ *
+ * A separate walk from the tree on purpose: the palette wants paths and nothing else, and
+ * it reads the whole tree once instead of per folder.
+ */
+
+import type { Dirent } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+/** Directory names the quick-open index never walks. */
+export const INDEX_IGNORED_DIRS = new Set([".git", "node_modules"]);
+
+export interface FileIndex {
+	files: string[];
+	truncated: boolean;
+}
+
+/**
+ * Walk `root` and collect file paths for the quick-open palette. Symlinks and
+ * the ignored directories are skipped, and the walk stops at `limit` files so a
+ * large tree cannot exhaust memory or time. Unreadable directories are skipped.
+ */
+export async function buildFileIndex(root: string, limit: number): Promise<FileIndex> {
+	const files: string[] = [];
+	let truncated = false;
+
+	async function walk(absDir: string, relDir: string): Promise<void> {
+		let dirents: Dirent[];
+		try {
+			dirents = await readdir(absDir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		dirents.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+		for (const dirent of dirents) {
+			if (truncated) return;
+			if (dirent.isSymbolicLink()) continue;
+			const rel = relDir ? `${relDir}/${dirent.name}` : dirent.name;
+			if (dirent.isDirectory()) {
+				if (INDEX_IGNORED_DIRS.has(dirent.name)) continue;
+				await walk(join(absDir, dirent.name), rel);
+			} else if (dirent.isFile()) {
+				if (files.length >= limit) {
+					truncated = true;
+					return;
+				}
+				files.push(rel);
+			}
+		}
+	}
+
+	await walk(root, "");
+	files.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()) || a.localeCompare(b));
+	return { files, truncated };
+}
+
+export type FileIndexProvider = () => Promise<FileIndex>;
+
+export interface FileIndexOptions {
+	/** How long a built index is reused, in ms (default 10000). */
+	ttlMs?: number;
+	/** Wall-clock seam; defaults to the real clock. */
+	now?: () => number;
+}
+
+/** A cached `buildFileIndex` for `root`; concurrent calls share one walk. */
+export function createFileIndex(root: string, limit: number, options: FileIndexOptions = {}): FileIndexProvider {
+	const ttlMs = options.ttlMs ?? 10_000;
+	const now = options.now ?? (() => Date.now());
+	let cached: FileIndex | undefined;
+	let checkedAt = 0;
+	let pending: Promise<FileIndex> | undefined;
+	return async () => {
+		const time = now();
+		if (cached && time - checkedAt < ttlMs) return cached;
+		if (pending) return pending;
+		pending = buildFileIndex(root, limit)
+			.then((index) => {
+				cached = index;
+				checkedAt = now();
+				return index;
+			})
+			.finally(() => {
+				pending = undefined;
+			});
+		return pending;
+	};
+}