@gavin-hu/my-pi-agent 0.19.0 → 0.21.0

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/check/render.ts

@@ -16,6 +16,7 @@ import type { Component } from "@earendil-works/pi-tui";
 import { sanitizeLine } from "../../lib/format.ts";
 import { clip } from "../../lib/tui/columns.ts";
 import { expandHint, GLYPHS, SEPARATORS } from "../../lib/tui/glyphs.ts";
+import { RenderCache } from "../../lib/tui/render-cache.ts";
 import { listRow } from "../../lib/tui/rows.ts";
 import { paint, type TuiRole } from "../../lib/tui/tokens.ts";
 import { earlierHint } from "../../lib/tui/tool.ts";
@@ -134,6 +135,7 @@ export interface CheckResultInput {
 export class CheckResultBlock implements Component {
 	private input: CheckResultInput;
 	private theme: Theme;
+	private readonly cache = new RenderCache();
 
 	constructor(input: CheckResultInput, theme: Theme) {
 		this.input = input;
@@ -144,12 +146,19 @@ export class CheckResultBlock implements Component {
 	setInput(input: CheckResultInput, theme: Theme): void {
 		this.input = input;
 		this.theme = theme;
+		this.cache.invalidate();
 	}
 
-	invalidate(): void {}
+	invalidate(): void {
+		this.cache.invalidate();
+	}
 
 	render(width: number): string[] {
 		const w = Math.max(1, width);
+		return this.cache.lines(w, undefined, () => this.build(w));
+	}
+
+	private build(w: number): string[] {
 		const theme = this.theme;
 		const { details, expanded } = this.input;
 		const role = statusRole(details.status);

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

@@ -2,16 +2,14 @@
  * Configuration for the browse extension.
  *
  * The `file-browse` section of the shared `bytefly.json` (global then project,
- * project wins). Everything
- * is validated and clamped so a typo cannot produce a nonsensical server.
+ * project wins). Everything is validated and clamped so a typo cannot produce a
+ * nonsensical page. The port is not here: the session serves every page on one, and
+ * `serve.port` is where that is pinned.
  */
 
-import { randomInt } from "node:crypto";
 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. */
-	port: number;
 	/** Open the default browser when the server starts. */
 	autoOpen: boolean;
 	/** Files larger than this are not rendered inline. */
@@ -43,7 +41,6 @@ export interface ServeConfig {
 }
 
 export const DEFAULT_CONFIG: ServeConfig = {
-	port: 0,
 	autoOpen: true,
 	maxFileBytes: 1024 * 1024,
 	maxThumbBytes: 5 * 1024 * 1024,
@@ -60,12 +57,6 @@ export const DEFAULT_CONFIG: ServeConfig = {
 	liveIntervalMs: 5000,
 };
 
-/** Base of the per-session port range. */
-export const PORT_BASE = 4780;
-
-/** Number of ports in the per-session range. */
-export const PORT_RANGE = 1000;
-
 /** Fastest live-status cadence a page may be given: short enough to watch, and a
  * floor so a page cannot outrun the git reads behind each frame. */
 export const LIVE_INTERVAL_MIN = 250;
@@ -76,7 +67,7 @@ export const LIVE_INTERVAL_MAX = 60_000;
 /**
  * How long the server keeps listening once the last page has gone. A reload or a
  * navigation detaches the stream and re-attaches within a moment, so the grace has
- * to outlast one; a closed window never re-attaches, and the port is released
+ * to outlast one; a closed window never re-attaches, and the prefix is given back
  * instead of listening for nobody until the session ends.
  */
 export const IDLE_STOP_MS = 10_000;
@@ -90,11 +81,6 @@ export const IDLE_STOP_MS = 10_000;
  */
 export const LIVE_MAX_CLIENTS = 8;
 
-/** A random port in the per-session range `PORT_BASE`–`PORT_BASE + PORT_RANGE - 1`. */
-export function randomPort(): number {
-	return PORT_BASE + randomInt(PORT_RANGE);
-}
-
 /** Validate and clamp a raw config object over the defaults. */
 export function normalizeConfig(
 	raw: Record<string, unknown> | undefined,
@@ -102,7 +88,6 @@ export function normalizeConfig(
 ): ServeConfig {
 	if (!raw) return base;
 	return {
-		port: clampInteger(raw.port, base.port, 0, 65535),
 		autoOpen: asBoolean(raw.autoOpen, base.autoOpen),
 		maxFileBytes: clampInteger(raw.maxFileBytes, base.maxFileBytes, 0, 1024 * 1024 * 1024),
 		maxThumbBytes: clampInteger(raw.maxThumbBytes, base.maxThumbBytes, 0, 1024 * 1024 * 1024),

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";
+}