@code-yeongyu/senpi-codemode 2026.7.25-2

package/src/tool/image.ts

@@ -0,0 +1,274 @@
+import { writeFile } from "node:fs/promises";
+import type { AgentToolResult, ExtensionContext } from "@code-yeongyu/senpi";
+import { convertToPng, formatDimensionNote, resizeImage } from "@code-yeongyu/senpi";
+import type { KernelToHostMessage } from "../bridge/protocol.ts";
+import type { TruncationMeta } from "../output/output-meta.ts";
+import {
+	artifactNotice,
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	OutputSink,
+	type OutputSummary,
+	TailBuffer,
+	truncateTail,
+} from "../output/streaming-output.ts";
+
+const MAX_DISPLAY_TEXT_BYTES = 8_000;
+
+export interface EvalImageContent {
+	readonly type: "image";
+	readonly data: string;
+	readonly mimeType: string;
+}
+
+export interface EvalImageResizeResult {
+	readonly image: EvalImageContent;
+	readonly dimensionNote?: string;
+}
+
+export type EvalImageResizer = (
+	image: EvalImageContent,
+	model: ExtensionContext["model"],
+) => Promise<EvalImageResizeResult>;
+
+export interface EvalOutputOptions {
+	readonly artifactPath?: string;
+	readonly headBytes: number;
+	readonly maxColumns: number;
+	readonly model: ExtensionContext["model"];
+	readonly imageResizer?: EvalImageResizer;
+	readonly onChunk: (aggregateText: string, cellText: string) => void;
+}
+
+export interface EvalOutputResult {
+	readonly output: string;
+	readonly images: readonly EvalImageContent[];
+	readonly jsonOutputs: readonly unknown[];
+	readonly hasMarkdown: boolean;
+	readonly truncated: boolean;
+	readonly notice?: string;
+	readonly meta?: TruncationMeta;
+}
+
+type DisplayMessage = Extract<KernelToHostMessage, { type: "display" }>;
+type WebpModel = { readonly provider: string; readonly api: string } | undefined;
+
+class DisplayPayloadError extends Error {
+	readonly name = "DisplayPayloadError";
+
+	constructor(mimeType: string, cause: SyntaxError) {
+		super(`Invalid ${mimeType} display payload: ${cause.message}`, { cause });
+	}
+}
+
+export class EvalOutputCollector {
+	readonly #options: EvalOutputOptions;
+	readonly #sink: OutputSink;
+	readonly #aggregateTail = new TailBuffer(DEFAULT_MAX_BYTES * 2);
+	readonly #cellTail = new TailBuffer(DEFAULT_MAX_BYTES * 2);
+	readonly #displayImages: EvalImageContent[] = [];
+	readonly #images: EvalImageContent[] = [];
+	readonly #jsonOutputs: unknown[] = [];
+	#hasMarkdown = false;
+	#imagesProcessed = false;
+
+	constructor(options: EvalOutputOptions) {
+		this.#options = options;
+		this.#sink = new OutputSink({
+			artifactPath: options.artifactPath,
+			headBytes: options.headBytes,
+			maxColumns: options.maxColumns,
+			onChunk: (chunk) => {
+				this.#aggregateTail.append(chunk);
+				this.#cellTail.append(chunk);
+				options.onChunk(this.#aggregateTail.text(), this.#cellTail.text());
+			},
+		});
+	}
+
+	push(text: string): void {
+		this.#sink.push(text);
+	}
+
+	display(message: DisplayMessage): void {
+		if (message.mimeType.startsWith("image/")) {
+			this.#displayImages.push({ type: "image", mimeType: message.mimeType, data: message.dataBase64 });
+			return;
+		}
+		const text = Buffer.from(message.dataBase64, "base64").toString("utf8");
+		if (message.mimeType === "application/json") {
+			let value: unknown;
+			try {
+				value = JSON.parse(text);
+			} catch (error) {
+				if (error instanceof SyntaxError) throw new DisplayPayloadError(message.mimeType, error);
+				throw error;
+			}
+			this.#jsonOutputs.push(value);
+			this.#sink.push(`display[${this.#jsonOutputs.length}]:\n${formatDisplayJson(value)}\n`);
+			return;
+		}
+		if (message.mimeType === "text/markdown") this.#hasMarkdown = true;
+		this.#sink.push(text.endsWith("\n") ? text : `${text}\n`);
+	}
+
+	aggregateText(): string {
+		return this.#aggregateTail.text();
+	}
+
+	async finish(): Promise<EvalOutputResult> {
+		await this.#processImages();
+		const summary = await this.#finalSummary();
+		const meta = truncationMetaFromSummary(summary);
+		const notice = summary.artifactId === undefined ? undefined : artifactNotice(summary.artifactId);
+		return {
+			output: summary.output.trimEnd(),
+			images: [...this.#images],
+			jsonOutputs: [...this.#jsonOutputs],
+			hasMarkdown: this.#hasMarkdown,
+			truncated: summary.truncated,
+			...(notice === undefined ? {} : { notice }),
+			...(meta === undefined ? {} : { meta }),
+		};
+	}
+
+	async flush(): Promise<void> {
+		await this.#sink.dump();
+	}
+
+	async #processImages(): Promise<void> {
+		if (this.#imagesProcessed) return;
+		this.#imagesProcessed = true;
+		const resize = this.#options.imageResizer ?? resizeEvalImage;
+		for (const source of this.#displayImages) {
+			const resized = await resize(source, this.#options.model);
+			this.#images.push(resized.image);
+			const description = resized.dimensionNote ?? `[${resized.image.mimeType}]`;
+			this.#sink.push(`display image ${this.#images.length}: ${description}\n`);
+		}
+	}
+
+	async #finalSummary(): Promise<OutputSummary> {
+		const summary = await this.#sink.dump();
+		if (summary.truncated || summary.totalLines <= DEFAULT_MAX_LINES) return summary;
+		const truncated = truncateTail(summary.output, {
+			maxLines: DEFAULT_MAX_LINES,
+			maxBytes: Number.MAX_SAFE_INTEGER,
+		});
+		let artifactId = summary.artifactId;
+		if (artifactId === undefined && this.#options.artifactPath !== undefined) {
+			await writeFile(this.#options.artifactPath, this.#aggregateTail.text(), "utf8");
+			artifactId = this.#options.artifactPath;
+		}
+		return {
+			...summary,
+			output: truncated.content,
+			truncated: true,
+			outputLines: truncated.outputLines,
+			outputBytes: truncated.outputBytes,
+			...(artifactId === undefined ? {} : { artifactId }),
+		};
+	}
+}
+
+export function webpExclusionForModel(model: WebpModel): true | undefined {
+	if (model === undefined) return undefined;
+	return model.provider === "ollama" ||
+		model.provider === "ollama-cloud" ||
+		model.provider === "llama.cpp" ||
+		model.provider === "lm-studio" ||
+		model.provider === "local-server" ||
+		model.api === "ollama-chat"
+		? true
+		: undefined;
+}
+
+export const resizeEvalImage: EvalImageResizer = async (image, model) => {
+	const excludeWebP = webpExclusionForModel(model);
+	const forceWebpConversion = excludeWebP === true && image.mimeType === "image/webp";
+	const resized = await resizeImage(
+		Buffer.from(image.data, "base64"),
+		image.mimeType,
+		forceWebpConversion ? { maxBytes: Buffer.byteLength(image.data, "utf8") } : undefined,
+	);
+	let output: EvalImageContent =
+		resized === null ? image : { type: "image", data: resized.data, mimeType: resized.mimeType };
+	if (excludeWebP === true && output.mimeType === "image/webp") {
+		const converted = await convertToPng(output.data, output.mimeType);
+		if (converted === null)
+			throw new TypeError(`Unable to convert ${output.mimeType} display output for the active model`);
+		output = { type: "image", data: converted.data, mimeType: converted.mimeType };
+	}
+	const dimensionNote = resized === null ? undefined : formatDimensionNote(resized);
+	return { image: output, ...(dimensionNote === undefined ? {} : { dimensionNote }) };
+};
+
+function formatDisplayJson(value: unknown): string {
+	let text: string;
+	try {
+		text = JSON.stringify(value, null, 2) ?? String(value);
+	} catch (error) {
+		if (!(error instanceof TypeError)) throw error;
+		text = String(value);
+	}
+	if (text.length <= MAX_DISPLAY_TEXT_BYTES) return text;
+	return `${text.slice(0, MAX_DISPLAY_TEXT_BYTES)}\n[…${text.length - MAX_DISPLAY_TEXT_BYTES}ch elided…]`;
+}
+
+function truncationMetaFromSummary(summary: OutputSummary): TruncationMeta | undefined {
+	if (!summary.truncated) return undefined;
+	const artifact = summary.artifactId === undefined ? {} : { artifactId: summary.artifactId };
+	if (summary.elidedBytes !== undefined && summary.elidedBytes > 0) {
+		const elidedLines = summary.elidedLines ?? Math.max(0, summary.totalLines - summary.outputLines);
+		const keptLines = Math.max(0, summary.outputLines - 1);
+		const headLines = Math.ceil(keptLines / 2);
+		const tailLines = keptLines - headLines;
+		return {
+			direction: "middle",
+			truncatedBy: "middle",
+			totalLines: summary.totalLines,
+			totalBytes: summary.totalBytes,
+			outputLines: summary.outputLines,
+			outputBytes: summary.outputBytes,
+			...(headLines > 0 ? { headRange: { start: 1, end: headLines } } : {}),
+			...(tailLines > 0
+				? { tailRange: { start: summary.totalLines - tailLines + 1, end: summary.totalLines } }
+				: {}),
+			elidedBytes: summary.elidedBytes,
+			elidedLines,
+			...artifact,
+		};
+	}
+	return {
+		direction: "tail",
+		truncatedBy: summary.outputBytes < summary.totalBytes ? "bytes" : "lines",
+		totalLines: summary.totalLines,
+		totalBytes: summary.totalBytes,
+		outputLines: summary.outputLines,
+		outputBytes: summary.outputBytes,
+		shownRange: { start: Math.max(1, summary.totalLines - summary.outputLines + 1), end: summary.totalLines },
+		...artifact,
+	};
+}
+
+export function marshalToolResult(result: AgentToolResult<unknown>) {
+	const texts = result.content.filter((part) => part.type === "text").map((part) => part.text);
+	const images = result.content
+		.filter((part) => part.type === "image")
+		.map((part) => ({ mimeType: part.mimeType, dataBase64: part.data }));
+	const details =
+		typeof result.details === "object" &&
+		result.details !== null &&
+		!Array.isArray(result.details) &&
+		Object.keys(result.details).length === 0
+			? undefined
+			: result.details;
+	const hasError = toolResultIsError(result);
+	const text = texts.join("\n");
+	return images.length === 0 && details === undefined && !hasError ? { text } : { text, details, images, hasError };
+}
+
+export function toolResultIsError(result: AgentToolResult<unknown>): boolean {
+	const details = result.details;
+	return typeof details === "object" && details !== null && "isError" in details && details.isError === true;
+}

package/src/tool/json-tree.ts

@@ -0,0 +1,247 @@
+import type { Theme, ThemeColor } from "@code-yeongyu/senpi";
+
+export const JSON_TREE_MAX_DEPTH_COLLAPSED = 2;
+export const JSON_TREE_MAX_DEPTH_EXPANDED = 6;
+export const JSON_TREE_MAX_LINES_COLLAPSED = 6;
+export const JSON_TREE_MAX_LINES_EXPANDED = 200;
+export const JSON_TREE_SCALAR_LEN_COLLAPSED = 60;
+export const JSON_TREE_SCALAR_LEN_EXPANDED = 2000;
+
+const HIDDEN_KEYS = { i: true, __partialJson: true } as const;
+const TREE_VERTICAL = "│  ";
+const TREE_BRANCH = "├─";
+const TREE_LAST = "└─";
+// Senpi's Theme exposes fg() but not omp's tree/icon helpers, so fixed glyphs
+// replace styledSymbol() while the existing dim/muted color names map directly.
+const OBJECT_GLYPH = "◆";
+const ARRAY_GLYPH = "◇";
+const SCALAR_GLYPH = "•";
+
+type JsonTreeResult = { readonly lines: string[]; readonly truncated: boolean };
+type RenderNode = readonly [
+	value: unknown,
+	key: string | undefined,
+	ancestors: boolean[],
+	isLast: boolean,
+	depth: number,
+];
+type RenderState = {
+	readonly lines: string[];
+	readonly theme: Theme | undefined;
+	readonly maxDepth: number;
+	readonly maxLines: number;
+	readonly maxScalarLen: number;
+	readonly activeObjects: Set<object>;
+	truncated: boolean;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function style(theme: Theme | undefined, color: ThemeColor, text: string): string {
+	return theme === undefined ? text : theme.fg(color, text);
+}
+
+function textWidth(text: string): number {
+	let width = 0;
+	for (const character of text) width += character === "\t" ? 4 : 1;
+	return width;
+}
+
+function truncateToColumns(text: string, maxColumns: number): string {
+	const limit = Math.max(0, Math.floor(maxColumns));
+	if (textWidth(text) <= limit) return text;
+	if (limit === 0) return "";
+	const marker = "…";
+	const prefixLimit = Math.max(0, limit - textWidth(marker));
+	let prefix = "";
+	let width = 0;
+	for (const character of text) {
+		const characterWidth = character === "\t" ? 4 : 1;
+		if (width + characterWidth > prefixLimit) break;
+		prefix += character;
+		width += characterWidth;
+	}
+	return `${prefix}${marker}`;
+}
+
+export function formatScalar(value: unknown, maxLen: number): string {
+	if (value === null) return "null";
+	if (value === undefined) return "undefined";
+	if (typeof value === "boolean" || typeof value === "number") return String(value);
+	if (typeof value === "string") {
+		const escaped = value.replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+		return `"${truncateToColumns(escaped, maxLen)}"`;
+	}
+	if (Array.isArray(value)) return `[${value.length} items]`;
+	if (typeof value === "object") return `{${Object.keys(value).length} keys}`;
+	return String(value);
+}
+
+function buildTreePrefix(theme: Theme | undefined, ancestors: readonly boolean[]): string {
+	return ancestors.map((hasNext) => style(theme, "dim", hasNext ? TREE_VERTICAL : "   ")).join("");
+}
+
+export function renderJsonTreeLines(
+	value: unknown,
+	theme: Theme | undefined,
+	maxDepth: number,
+	maxLines: number,
+	maxScalarLen: number,
+): JsonTreeResult {
+	const state: RenderState = {
+		lines: [],
+		theme,
+		maxDepth: Math.max(0, Math.floor(maxDepth)),
+		maxLines: Math.max(0, Math.floor(maxLines)),
+		maxScalarLen: Math.max(0, Math.floor(maxScalarLen)),
+		activeObjects: new Set<object>(),
+		truncated: false,
+	};
+
+	const pushLine = (line: string): boolean => {
+		if (state.lines.length >= state.maxLines) {
+			state.truncated = true;
+			return false;
+		}
+		state.lines.push(line);
+		return true;
+	};
+
+	const renderNode = (node: RenderNode): void => {
+		const [value, key, ancestors, isLast, depth] = node;
+		if (state.lines.length >= state.maxLines) {
+			state.truncated = true;
+			return;
+		}
+		const connector = isLast ? TREE_LAST : TREE_BRANCH;
+		const prefix = `${buildTreePrefix(state.theme, ancestors)}${style(state.theme, "dim", connector)} `;
+		const objectValue = value !== null && typeof value === "object" ? value : undefined;
+		if (objectValue !== undefined && state.activeObjects.has(objectValue)) {
+			pushLine(`${prefix}${style(state.theme, "dim", "… (circular)")}`);
+			return;
+		}
+		if (objectValue !== undefined) state.activeObjects.add(objectValue);
+		ancestors.push(!isLast);
+		try {
+			if (value === null || value === undefined || typeof value !== "object") {
+				const label = key ? style(state.theme, "muted", key) : style(state.theme, "muted", "value");
+				if (typeof value === "string" && value.includes("\n")) {
+					const stringLines = value.split("\n");
+					const visibleLines = Math.min(stringLines.length, Math.max(1, state.maxLines - state.lines.length - 1));
+					const first = truncateToColumns(stringLines[0] ?? "", state.maxScalarLen);
+					if (
+						!pushLine(
+							`${prefix}${style(state.theme, "muted", SCALAR_GLYPH)} ${label}: ${style(state.theme, "dim", `"${first}`)}`,
+						)
+					)
+						return;
+					const continuePrefix = buildTreePrefix(state.theme, ancestors);
+					for (let index = 1; index < visibleLines; index += 1) {
+						const line = truncateToColumns(stringLines[index] ?? "", state.maxScalarLen);
+						if (!pushLine(`${continuePrefix}   ${style(state.theme, "dim", ` ${line}`)}`)) return;
+					}
+					if (stringLines.length > visibleLines) {
+						state.truncated = true;
+						pushLine(
+							`${continuePrefix}   ${style(state.theme, "dim", ` …(${stringLines.length - visibleLines} more lines)"`)}`,
+						);
+					} else {
+						const lastIndex = state.lines.length - 1;
+						const lastLine = state.lines[lastIndex];
+						if (lastLine !== undefined) state.lines[lastIndex] = `${lastLine}${style(state.theme, "dim", '"')}`;
+					}
+					return;
+				}
+				pushLine(
+					`${prefix}${style(state.theme, "muted", SCALAR_GLYPH)} ${label}: ${style(state.theme, "dim", formatScalar(value, state.maxScalarLen))}`,
+				);
+				return;
+			}
+
+			if (Array.isArray(value)) {
+				const label = key ? key : "array";
+				if (!pushLine(`${prefix}${style(state.theme, "muted", ARRAY_GLYPH)} ${style(state.theme, "muted", label)}`))
+					return;
+				if (value.length === 0) {
+					pushLine(
+						`${buildTreePrefix(state.theme, ancestors)}${style(state.theme, "dim", TREE_LAST)} ${style(state.theme, "dim", "[]")}`,
+					);
+					return;
+				}
+				if (depth >= state.maxDepth) {
+					pushLine(
+						`${buildTreePrefix(state.theme, ancestors)}${style(state.theme, "dim", TREE_LAST)} ${style(state.theme, "dim", "…")}`,
+					);
+					return;
+				}
+				for (const [index, child] of value.entries()) {
+					renderNode([child, `[${index}]`, ancestors, index === value.length - 1, depth + 1]);
+					if (state.lines.length >= state.maxLines) {
+						state.truncated = true;
+						return;
+					}
+				}
+				return;
+			}
+
+			if (!isRecord(value)) return;
+			const label = key ? key : "object";
+			if (!pushLine(`${prefix}${style(state.theme, "muted", OBJECT_GLYPH)} ${style(state.theme, "muted", label)}`))
+				return;
+			if (depth >= state.maxDepth) {
+				pushLine(
+					`${buildTreePrefix(state.theme, ancestors)}${style(state.theme, "dim", TREE_LAST)} ${style(state.theme, "dim", "…")}`,
+				);
+				return;
+			}
+			const keys = Object.keys(value);
+			if (keys.length === 0) {
+				pushLine(
+					`${buildTreePrefix(state.theme, ancestors)}${style(state.theme, "dim", TREE_LAST)} ${style(state.theme, "dim", "{}")}`,
+				);
+				return;
+			}
+			for (const [index, key] of keys.entries()) {
+				renderNode([value[key], key, ancestors, index === keys.length - 1, depth + 1]);
+				if (state.lines.length >= state.maxLines) {
+					state.truncated = true;
+					return;
+				}
+			}
+		} finally {
+			ancestors.pop();
+			if (objectValue !== undefined) state.activeObjects.delete(objectValue);
+		}
+	};
+
+	const rootObject = value !== null && typeof value === "object" ? value : undefined;
+	if (rootObject !== undefined) state.activeObjects.add(rootObject);
+	try {
+		if (isRecord(value)) {
+			const keys = Object.keys(value).filter((key) => !Object.hasOwn(HIDDEN_KEYS, key));
+			for (const [index, key] of keys.entries()) {
+				renderNode([value[key], key, [], index === keys.length - 1, 1]);
+				if (state.lines.length >= state.maxLines) {
+					state.truncated = true;
+					break;
+				}
+			}
+		} else if (Array.isArray(value)) {
+			for (const [index, child] of value.entries()) {
+				renderNode([child, `[${index}]`, [], index === value.length - 1, 1]);
+				if (state.lines.length >= state.maxLines) {
+					state.truncated = true;
+					break;
+				}
+			}
+		} else {
+			renderNode([value, undefined, [], true, 0]);
+		}
+	} finally {
+		if (rootObject !== undefined) state.activeObjects.delete(rootObject);
+	}
+
+	return { lines: state.lines, truncated: state.truncated };
+}