@oh-my-pi/pi-coding-agent 16.1.6 → 16.1.8

package/src/tiny/title-client.ts

@@ -296,6 +296,7 @@ export class TinyTitleClient {
 	#unsubscribeMessage: (() => void) | null = null;
 	#unsubscribeError: (() => void) | null = null;
 	#pending = new Map<string, PendingRequest>();
+	#failedModels = new Set<TinyLocalModelKey>();
 	#progressListeners = new Set<(event: TinyTitleProgressEvent) => void>();
 	#nextRequestId = 0;
 	#spawnWorker: () => WorkerHandle;
@@ -318,7 +319,7 @@ export class TinyTitleClient {
 	): Promise<string | null> {
 		const options = normalizeTinyTitleGenerateOptions(optionsOrSignal);
 		if (!isTinyTitleLocalModelKey(modelKey)) return null;
-		if (options.signal?.aborted) return null;
+		if (options.signal?.aborted || this.#failedModels.has(modelKey)) return null;
 
 		try {
 			const worker = this.#ensureWorker();
@@ -357,7 +358,7 @@ export class TinyTitleClient {
 		options: { maxTokens?: number; signal?: AbortSignal } = {},
 	): Promise<string | null> {
 		if (!isTinyMemoryLocalModelKey(modelKey)) return null;
-		if (options.signal?.aborted) return null;
+		if (options.signal?.aborted || this.#failedModels.has(modelKey)) return null;
 
 		try {
 			const worker = this.#ensureWorker();
@@ -478,12 +479,17 @@ export class TinyTitleClient {
 			return;
 		}
 		logger.debug("tiny-title: worker returned error", { error: message.error });
+		this.#markFailedModel(pending);
 		this.#emitProgress({ modelKey: pending.modelKey, status: "error" });
 		if (pending.kind === "generate" || pending.kind === "complete") pending.resolve(null);
 		else pending.resolve(false);
 		void this.terminate();
 	}
 
+	#markFailedModel(pending: PendingRequest): void {
+		if (pending.kind === "generate" || pending.kind === "complete") this.#failedModels.add(pending.modelKey);
+	}
+
 	#emitProgress(event: TinyTitleProgressEvent): void {
 		for (const listener of this.#progressListeners) listener(event);
 	}

package/src/tiny/worker.ts

@@ -317,6 +317,7 @@ async function loadPipeline(
 ): Promise<TextGenerationPipeline> {
 	const spec = getTinyLocalModelSpec(modelKey);
 	if (!spec) throw new Error(`Unknown tiny local model: ${modelKey}`);
+	if (spec.unsupportedReason) throw new Error(`${modelKey} is unavailable: ${spec.unsupportedReason}`);
 	const cached = pipelines.get(modelKey);
 	if (cached) {
 		void cached

package/src/tools/search.ts

@@ -278,6 +278,15 @@ interface InternalSearchInputResolution {
 	virtualScopePath?: string;
 }
 
+function isImmutableSourcePath(filePath: string, immutableSourcePaths: ReadonlySet<string>): boolean {
+	for (const immutablePath of immutableSourcePaths) {
+		if (filePath === immutablePath || filePath.startsWith(`${immutablePath}${path.sep}`)) {
+			return true;
+		}
+	}
+	return false;
+}
+
 interface IndexedContentLines {
 	lines: string[];
 	starts: number[];
@@ -1131,7 +1140,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					for (const relativePath of fileList) {
 						if (archiveDisplaySet.has(relativePath) || virtualPathSet.has(relativePath)) continue;
 						const absoluteFilePath = path.resolve(this.session.cwd, relativePath);
-						if (immutableSourcePaths.has(absoluteFilePath)) continue;
+						if (isImmutableSourcePath(absoluteFilePath, immutableSourcePaths)) continue;
 						// Mint a whole-file content tag so any anchor validates while the
 						// file is unchanged; over-cap / unreadable files get no tag (and
 						// therefore plain, non-editable line output).

package/src/tools/sqlite-reader.ts

@@ -21,7 +21,19 @@ const MAX_QUERY_LIMIT = 500;
 export const MAX_RAW_QUERY_ROWS = 1000;
 const MAX_RENDER_WIDTH = 120;
 const MAX_COLUMN_WIDTH = 40;
-const MIN_COLUMN_WIDTH = 1;
+/**
+ * Floor for each ASCII-table column. At width 2 (or 1) every multi-char cell
+ * collapses to a lone ellipsis, so the renderer keeps each column wide enough
+ * to show at least one real glyph alongside the ellipsis (e.g. `Fo…`). When a
+ * row has too many columns to honor this floor inside `MAX_RENDER_WIDTH`,
+ * `buildAsciiTable` falls back to per-row vertical blocks via
+ * {@link buildVerticalBlocks} — issue #3107.
+ */
+const MIN_COLUMN_WIDTH = 3;
+/** Separator overhead per column in the ASCII table (`" | "`). */
+const COLUMN_SEPARATOR_WIDTH = 3;
+/** Constant frame overhead added once to every row (leading `"|"` + trailing `" |"` after the per-column accounting). */
+const TABLE_FRAME_WIDTH = 1;
 /**
  * Upper bound on rows scanned when counting a table for the listing. SQLite has
  * no stored row count, so `COUNT(*)` is a full b-tree scan — multi-second on a
@@ -142,10 +154,53 @@ function padCell(value: string, width: number): string {
 	return `${truncated}${" ".repeat(width - visibleWidth)}`;
 }
 
+/**
+ * Width budget the ASCII layout needs at the floor (each column at
+ * `MIN_COLUMN_WIDTH`). When this exceeds `MAX_RENDER_WIDTH`, no choice of
+ * per-column widths can fit the header inside the budget — every cell is then
+ * forced down to width 1 by the shrink loop, rendering as a lone ellipsis, and
+ * the right edge is still chopped by the final per-line truncation (#3107).
+ */
+function tableFitsAtMinimum(columnCount: number): boolean {
+	return MIN_COLUMN_WIDTH * columnCount + COLUMN_SEPARATOR_WIDTH * columnCount + TABLE_FRAME_WIDTH <= MAX_RENDER_WIDTH;
+}
+
+/**
+ * Vertical fallback used when a table has too many columns to fit horizontally
+ * (>19 at the default 120-cell budget). Each row becomes a labelled block of
+ * `column: value` lines, mirroring `psql`'s expanded display mode. Column
+ * names are right-padded so colons align; the value is left raw and the whole
+ * line is truncated at `MAX_RENDER_WIDTH`.
+ */
+function buildVerticalBlocks(columns: string[], rows: SqliteRow[]): string {
+	if (rows.length === 0) {
+		return "(no rows)";
+	}
+	let nameWidth = MIN_COLUMN_WIDTH;
+	for (const column of columns) {
+		nameWidth = Math.max(nameWidth, Bun.stringWidth(sanitizeCell(column)));
+	}
+	nameWidth = Math.min(MAX_COLUMN_WIDTH, nameWidth);
+	return rows
+		.map((row, index) => {
+			const block = [`── Row ${index + 1} ──`];
+			for (const column of columns) {
+				const name = padCell(column, nameWidth);
+				const value = sanitizeCell(stringifySqliteValue(row[column]));
+				block.push(truncateToWidth(`${name}: ${value}`, MAX_RENDER_WIDTH));
+			}
+			return block.join("\n");
+		})
+		.join("\n\n");
+}
+
 function buildAsciiTable(columns: string[], rows: SqliteRow[]): string {
 	if (columns.length === 0) {
 		return rows.length === 0 ? "(no rows)" : "(rows returned without named columns)";
 	}
+	if (!tableFitsAtMinimum(columns.length)) {
+		return buildVerticalBlocks(columns, rows);
+	}
 
 	const widths = columns.map(column =>
 		Math.max(MIN_COLUMN_WIDTH, Math.min(MAX_COLUMN_WIDTH, Bun.stringWidth(sanitizeCell(column)))),
@@ -157,7 +212,8 @@ function buildAsciiTable(columns: string[], rows: SqliteRow[]): string {
 		}
 	}
 
-	let totalWidth = widths.reduce((sum, width) => sum + width, 0) + columns.length * 3 + 1;
+	const overhead = columns.length * COLUMN_SEPARATOR_WIDTH + TABLE_FRAME_WIDTH;
+	let totalWidth = widths.reduce((sum, width) => sum + width, 0) + overhead;
 	while (totalWidth > MAX_RENDER_WIDTH) {
 		let widestIndex = -1;
 		let widestWidth = MIN_COLUMN_WIDTH;
@@ -169,7 +225,7 @@ function buildAsciiTable(columns: string[], rows: SqliteRow[]): string {
 		}
 		if (widestIndex === -1) break;
 		widths[widestIndex] = Math.max(MIN_COLUMN_WIDTH, (widths[widestIndex] ?? MIN_COLUMN_WIDTH) - 1);
-		totalWidth = widths.reduce((sum, width) => sum + width, 0) + columns.length * 3 + 1;
+		totalWidth = widths.reduce((sum, width) => sum + width, 0) + overhead;
 	}
 
 	const header = `| ${columns.map((column, index) => padCell(column, widths[index] ?? MIN_COLUMN_WIDTH)).join(" | ")} |`;

package/src/tools/todo.ts

@@ -11,6 +11,7 @@ import todoDescription from "../prompts/tools/todo.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
 import type { SessionEntry } from "../session/session-entries";
 import { framedBlock, renderStatusLine, renderTreeList } from "../tui";
+import { normalizePathLikeInput, resolveToCwd } from "./path-utils";
 import { formatErrorDetail, PREVIEW_LIMITS } from "./render-utils";
 
 // =============================================================================
@@ -428,6 +429,11 @@ const STATUS_TO_MARKER: Record<TodoStatus, string> = {
 	abandoned: "-",
 };
 
+export function resolveTodoMarkdownPath(input: string, cwd: string): string {
+	const raw = normalizePathLikeInput(input) || "TODO.md";
+	return resolveToCwd(raw, cwd);
+}
+
 /** Render todo phases as a Markdown checklist suitable for editing/copying. */
 export function phasesToMarkdown(phases: TodoPhase[]): string {
 	if (phases.length === 0) return "# Todos\n";

package/src/tools/write.ts

@@ -1068,14 +1068,12 @@ export const writeToolRenderer = {
 		const lang = getLanguageFromPath(rawPath) ?? "text";
 		const langIcon = uiTheme.fg("muted", uiTheme.getLangIcon(lang));
 		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
-		// Static pending icon, never the animated glyph: the header is the head
-		// row of the framed block, and native-scrollback commits are prefix-only
-		// — an animating head row would pin the commit boundary at the top and
-		// keep a tall expanded preview from scroll-appending mid-stream. The
-		// liveness cue rides the trailing "(streaming)" line instead.
+		// No status icon on the head row: it's the head of the framed block, and
+		// native-scrollback commits are prefix-only — an animated glyph would pin
+		// the commit boundary at the top, and the pending hourglass just adds
+		// noise. The liveness cue rides the trailing "(streaming)" line instead.
 		const header = renderStatusLine(
 			{
-				icon: "pending",
 				title: "Write",
 				description: `${langIcon} ${pathDisplay}`,
 			},

package/src/utils/thinking-display.ts

@@ -9,3 +9,81 @@ export function canonicalizeMessage(text: string | null | undefined): string {
 	}
 	return "";
 }
+
+export function formatThinkingForDisplay(text: string, proseOnly: boolean): string {
+	if (!proseOnly || !text) return text;
+
+	const lines = text.split("\n");
+	const resultLines: string[] = [];
+	let inFence = false;
+	let fenceChar = "";
+	let fenceLen = 0;
+
+	const FENCE = /^( {0,3})([`~]{3,})/;
+	const appendEllipsis = () => {
+		let lastLineIdx = resultLines.length - 1;
+		while (lastLineIdx >= 0 && resultLines[lastLineIdx]!.trim() === "") {
+			lastLineIdx--;
+		}
+
+		if (lastLineIdx >= 0) {
+			const lastLine = resultLines[lastLineIdx]!;
+			const trimmed = lastLine.trimEnd();
+			if (trimmed.endsWith("...")) {
+				resultLines[lastLineIdx] = trimmed;
+			} else if (trimmed.endsWith(".")) {
+				resultLines[lastLineIdx] = `${trimmed.slice(0, -1)}...`;
+			} else {
+				resultLines[lastLineIdx] = `${trimmed}...`;
+			}
+		} else {
+			resultLines.push("...");
+		}
+	};
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i]!;
+		const open = FENCE.exec(line);
+
+		if (inFence) {
+			// A closing fence is the same char, at least as long, with nothing else on the line.
+			if (
+				open &&
+				open[2]![0] === fenceChar &&
+				open[2]!.length >= fenceLen &&
+				line.slice(open[1]!.length + open[2]!.length).trim() === ""
+			) {
+				inFence = false;
+				fenceChar = "";
+				fenceLen = 0;
+			}
+			// We skip all internal lines of a code fence.
+		} else if (open) {
+			const marker = open[2]!;
+			const ch = marker[0]!;
+			// A backtick fence's info string may not contain a backtick.
+			if (!(ch === "`" && line.slice(open[1]!.length + marker.length).includes("`"))) {
+				inFence = true;
+				fenceChar = ch;
+				fenceLen = marker.length;
+				appendEllipsis();
+			} else {
+				resultLines.push(line);
+			}
+		} else {
+			resultLines.push(line);
+		}
+	}
+
+	const formatted = resultLines.join("\n");
+	return formatted;
+}
+
+export function hasDisplayableThinking(
+	text: string | null | undefined,
+	formattedText: string | null | undefined,
+): boolean {
+	if (!text) return false;
+	if (!formattedText) return false;
+	return formattedText.length > 0 && canonicalizeMessage(text).length > 0;
+}