membot 0.8.0 → 0.10.0

package/src/operations/refresh.ts

@@ -3,9 +3,29 @@ import { resolveEmbeddingWorkers } from "../context.ts";
 import { listDueRefreshes } from "../db/files.ts";
 import { withEmbedderPool } from "../ingest/embedder-pool.ts";
 import { colors } from "../output/formatter.ts";
+import { isInteractive } from "../output/tty.ts";
 import { refreshOne } from "../refresh/runner.ts";
 import { defineOperation } from "./types.ts";
 
+interface RefreshEntry {
+	logical_path: string;
+	status: "ok" | "unchanged" | "failed";
+	new_version_id?: string;
+	error?: string;
+}
+
+/** Render one refresh result as a persistent stderr / final-summary line. */
+function formatEntryLine(p: RefreshEntry): string {
+	if (p.status === "ok") {
+		const ver = p.new_version_id ? colors.dim(`→ ${p.new_version_id}`) : "";
+		return `${colors.green("✓")} ${colors.cyan(p.logical_path)} ${ver}`;
+	}
+	if (p.status === "unchanged") {
+		return `${colors.dim("·")} ${colors.dim(p.logical_path)} ${colors.dim("(unchanged)")}`;
+	}
+	return `${colors.red("✗")} ${p.logical_path} ${colors.dim(p.error ?? "")}`;
+}
+
 export const refreshOperation = defineOperation({
 	name: "membot_refresh",
 	cliName: "refresh",
@@ -31,22 +51,23 @@ export const refreshOperation = defineOperation({
 		let updated = 0;
 		let unchanged = 0;
 		let failed = 0;
-		const lines = result.processed.map((p) => {
-			if (p.status === "ok") {
-				updated++;
-				const ver = p.new_version_id ? colors.dim(`→ ${p.new_version_id}`) : "";
-				return `${colors.green("✓")} ${colors.cyan(p.logical_path)} ${ver}`;
-			}
-			if (p.status === "unchanged") {
-				unchanged++;
-				return `${colors.dim("·")} ${colors.dim(p.logical_path)} ${colors.dim("(unchanged)")}`;
-			}
-			failed++;
-			return `${colors.red("✗")} ${p.logical_path} ${colors.dim(p.error ?? "")}`;
-		});
+		for (const p of result.processed) {
+			if (p.status === "ok") updated++;
+			else if (p.status === "unchanged") unchanged++;
+			else failed++;
+		}
 		const parts = [colors.green(`updated ${updated}`), colors.dim(`unchanged ${unchanged}`)];
 		if (failed) parts.push(colors.red(`failed ${failed}`));
-		return `${lines.join("\n")}\n${parts.join(", ")}`;
+		const summary = parts.join(", ");
+
+		// In interactive mode the per-entry results were already streamed to
+		// stderr via progress.entry() during the run; printing the same list
+		// to stdout would just duplicate the scrollback. Non-interactive
+		// callers (JSON, piped, CI) still get the full list.
+		if (isInteractive()) return summary;
+
+		const lines = result.processed.map(formatEntryLine);
+		return `${lines.join("\n")}\n${summary}`;
 	},
 	handler: async (input, ctx) => {
 		// Per-command embedder pool: workers come up at the start of the
@@ -57,21 +78,19 @@ export const refreshOperation = defineOperation({
 			const targets = input.logical_path
 				? [input.logical_path]
 				: (await listDueRefreshes(ctx.db)).map((r) => r.logical_path);
-			const out: Array<{
-				logical_path: string;
-				status: "ok" | "unchanged" | "failed";
-				new_version_id?: string;
-				error?: string;
-			}> = [];
+			const out: RefreshEntry[] = [];
 			ctx.progress.start(targets.length, "refresh");
 			for (const path of targets) {
-				ctx.progress.tick(path);
+				ctx.progress.setLabel(path);
+				let entry: RefreshEntry;
 				try {
-					const r = await refreshOne(ctx, path, input.force, (sublabel) => ctx.progress.update(sublabel));
-					out.push(r);
+					entry = await refreshOne(ctx, path, input.force, (sublabel) => ctx.progress.update(sublabel));
 				} catch (err) {
-					out.push({ logical_path: path, status: "failed", error: err instanceof Error ? err.message : String(err) });
+					entry = { logical_path: path, status: "failed", error: err instanceof Error ? err.message : String(err) };
 				}
+				out.push(entry);
+				ctx.progress.tick(path);
+				ctx.progress.entry(formatEntryLine(entry));
 			}
 			ctx.progress.done(`refresh: ${out.filter((r) => r.status === "ok").length}/${out.length} updated`);
 			return { processed: out, count: out.length };

package/src/output/formatter.ts

@@ -18,6 +18,27 @@ export function renderResult<T>(result: T, opts: { console_formatter?: (result:
 	return JSON.stringify(result, null, 2);
 }
 
+/**
+ * Format a byte count as a short human-readable string: 5654 → `5.5 KB`,
+ * 14_859 → `14.5 KB`, 2_345_678 → `2.2 MB`. Uses 1024-based units (binary
+ * prefixes) since file sizes on disk are typically reported that way.
+ * Negative or non-finite inputs render as `0 B`.
+ */
+export function formatBytes(n: number): string {
+	if (!Number.isFinite(n) || n < 0) return "0 B";
+	if (n < 1024) return `${n} B`;
+	const units = ["KB", "MB", "GB", "TB"] as const;
+	let value = n / 1024;
+	let unit: string = units[0];
+	for (let i = 1; i < units.length && value >= 1024; i++) {
+		value /= 1024;
+		unit = units[i] as string;
+	}
+	// One decimal until 100, then round to integer (so the column stays narrow).
+	const formatted = value < 100 ? value.toFixed(1) : `${Math.round(value)}`;
+	return `${formatted} ${unit}`;
+}
+
 /**
  * Pretty-print a 2D array of cells as an aligned table. Column widths are
  * computed from the visible (escape-stripped) length of each cell so coloured

package/src/output/logger.ts

@@ -9,6 +9,17 @@ export interface Spinner {
 	stop(): void;
 }
 
+/**
+ * Anything occupying a fixed area of stderr that needs to be torn down before
+ * the logger writes a stray line, then redrawn afterward. nanospinner's
+ * single-line spinner and progress.ts's multi-line worker view both implement
+ * this so log/info/warn lines don't shred the live display.
+ */
+export interface LiveArea {
+	clear(): void;
+	render(): void;
+}
+
 const NOOP_SPINNER: Spinner = { update() {}, success() {}, error() {}, stop() {} };
 
 /**
@@ -20,6 +31,7 @@ const NOOP_SPINNER: Spinner = { update() {}, success() {}, error() {}, stop() {}
 class Logger {
 	private static instance: Logger;
 	private activeSpinner: ReturnType<typeof createSpinner> | null = null;
+	private activeLiveArea: LiveArea | null = null;
 
 	/** Singleton accessor. Use the exported `logger` const instead in normal code. */
 	static getInstance(): Logger {
@@ -31,7 +43,24 @@ class Logger {
 		return useColor() ? fn(msg) : msg;
 	}
 
+	/**
+	 * Register a multi-line live display. Logger will `clear()` it before any
+	 * stderr write and `render()` it after, so log lines don't punch through
+	 * the live area. Pass null to deregister. Mutually exclusive with the
+	 * nanospinner path (only one live thing on stderr at a time).
+	 */
+	setActiveLiveArea(area: LiveArea | null): void {
+		this.activeLiveArea = area;
+	}
+
 	private writeStderr(msg: string): void {
+		const area = this.activeLiveArea;
+		if (area) {
+			area.clear();
+			process.stderr.write(`${msg}\n`);
+			area.render();
+			return;
+		}
 		if (this.activeSpinner) {
 			this.activeSpinner.clear();
 			process.stderr.write(`${msg}\n`);
@@ -66,6 +95,13 @@ class Logger {
 
 	/** Raw stderr write, no formatting added. Spinner-aware. */
 	writeRaw(msg: string): void {
+		const area = this.activeLiveArea;
+		if (area) {
+			area.clear();
+			process.stderr.write(msg);
+			area.render();
+			return;
+		}
 		if (this.activeSpinner) {
 			this.activeSpinner.clear();
 			process.stderr.write(msg);