@oh-my-pi/pi-coding-agent 10.3.2 → 10.6.0

package/src/tools/find.ts

@@ -286,8 +286,9 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				: undefined;
 			const timeoutSignal = AbortSignal.timeout(GLOB_TIMEOUT_MS);
 			const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-			try {
-				const result = await untilAborted(combinedSignal, () =>
+
+			const doGlob = async (useGitignore: boolean) =>
+				untilAborted(combinedSignal, () =>
 					glob(
 						{
 							pattern: globPattern,
@@ -296,10 +297,18 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 							hidden: includeHidden,
 							maxResults: effectiveLimit,
 							sortByMtime: true,
+							gitignore: useGitignore,
 						},
 						onMatch,
 					),
 				);
+
+			try {
+				let result = await doGlob(true);
+				// If gitignore filtering yielded nothing, retry without it
+				if (result.matches.length === 0) {
+					result = await doGlob(false);
+				}
 				matches = result.matches;
 			} catch (error) {
 				if (error instanceof Error && error.name === "AbortError") {

package/src/tools/grep.ts

@@ -1,7 +1,7 @@
 import * as nodePath from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
-import { type GrepMatch as WasmGrepMatch, grep as wasmGrep } from "@oh-my-pi/pi-natives";
+
+import { grep as wasmGrep } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { untilAborted } from "@oh-my-pi/pi-utils";
@@ -10,7 +10,7 @@ import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import grepDescription from "../prompts/tools/grep.md" with { type: "text" };
-import { renderFileList, renderStatusLine, renderTreeList } from "../tui";
+import { renderStatusLine, renderTreeList } from "../tui";
 import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
 import { resolveToCwd } from "./path-utils";
@@ -24,16 +24,11 @@ const grepSchema = Type.Object({
 	path: Type.Optional(Type.String({ description: "File or directory to search (default: cwd)" })),
 	glob: Type.Optional(Type.String({ description: "Filter files by glob pattern (e.g., '*.js')" })),
 	type: Type.Optional(Type.String({ description: "Filter by file type (e.g., js, py, rust)" })),
-	output_mode: Type.Optional(
-		StringEnum(["filesWithMatches", "content", "count"], {
-			description: "Output format (default: files_with_matches)",
-		}),
-	),
 	i: Type.Optional(Type.Boolean({ description: "Case-insensitive search (default: false)" })),
-	n: Type.Optional(Type.Boolean({ description: "Show line numbers (default: true)" })),
-	context: Type.Optional(Type.Number({ description: "Lines of context (default: 5)" })),
-	multiline: Type.Optional(Type.Boolean({ description: "Enable multiline matching (default: false)" })),
-	limit: Type.Optional(Type.Number({ description: "Limit output to first N matches (default: 100 in content mode)" })),
+	pre: Type.Optional(Type.Number({ description: "Lines of context before matches" })),
+	post: Type.Optional(Type.Number({ description: "Lines of context after matches" })),
+	multiline: Type.Optional(Type.Boolean({ description: "Enable multiline matching" })),
+	limit: Type.Optional(Type.Number({ description: "Limit output to first N matches (default: 100)" })),
 	offset: Type.Optional(Type.Number({ description: "Skip first N entries before applying limit (default: 0)" })),
 });
 
@@ -50,7 +45,6 @@ export interface GrepToolDetails {
 	fileCount?: number;
 	files?: string[];
 	fileMatches?: Array<{ path: string; count: number }>;
-	mode?: "content" | "filesWithMatches" | "count";
 	truncated?: boolean;
 	error?: string;
 }
@@ -86,7 +80,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 		_onUpdate?: AgentToolUpdateCallback<GrepToolDetails>,
 		_toolContext?: AgentToolContext,
 	): Promise<AgentToolResult<GrepToolDetails>> {
-		const { pattern, path: searchDir, glob, type, output_mode, i, n, context, multiline, limit, offset } = params;
+		const { pattern, path: searchDir, glob, type, i, pre, post, multiline, limit, offset } = params;
 
 		return untilAborted(signal, async () => {
 			const normalizedPattern = pattern.trim();
@@ -105,10 +99,13 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			}
 			const normalizedLimit = rawLimit !== undefined && rawLimit > 0 ? rawLimit : undefined;
 
-			const normalizedContext = context ?? 5;
-			const showLineNumbers = n ?? true;
+			const defaultContextBefore = this.session.settings.get("grep.contextBefore");
+			const defaultContextAfter = this.session.settings.get("grep.contextAfter");
+			const normalizedContextBefore = pre ?? defaultContextBefore;
+			const normalizedContextAfter = post ?? defaultContextAfter;
 			const ignoreCase = i ?? false;
-			const hasContentHints = limit !== undefined || context !== undefined;
+			const patternHasNewline = normalizedPattern.includes("\n") || normalizedPattern.includes("\\n");
+			const effectiveMultiline = multiline ?? patternHasNewline;
 
 			const searchPath = resolveToCwd(searchDir || ".", this.session.cwd);
 			const scopePath = (() => {
@@ -124,9 +121,8 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				throw new ToolError(`Path not found: ${searchPath}`);
 			}
 
-			const effectiveOutputMode = output_mode ?? (!isDirectory || hasContentHints ? "content" : "filesWithMatches");
-			const effectiveLimit =
-				effectiveOutputMode === "content" ? (normalizedLimit ?? DEFAULT_MATCH_LIMIT) : normalizedLimit;
+			const effectiveOutputMode = "content";
+			const effectiveLimit = normalizedLimit ?? DEFAULT_MATCH_LIMIT;
 
 			// Run WASM grep
 			let result: Awaited<ReturnType<typeof wasmGrep>>;
@@ -137,11 +133,12 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					glob: glob?.trim() || undefined,
 					type: type?.trim() || undefined,
 					ignoreCase,
-					multiline: multiline ?? false,
+					multiline: effectiveMultiline,
 					hidden: true,
 					maxCount: effectiveLimit,
 					offset: normalizedOffset > 0 ? normalizedOffset : undefined,
-					context: effectiveOutputMode === "content" ? normalizedContext : undefined,
+					contextBefore: normalizedContextBefore,
+					contextAfter: normalizedContextAfter,
 					maxColumns: DEFAULT_MAX_COLUMN,
 					mode: effectiveOutputMode,
 				});
@@ -180,71 +177,66 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					matchCount: 0,
 					fileCount: 0,
 					files: [],
-					mode: effectiveOutputMode,
 					truncated: false,
 				};
 				return toolResult(details).text("No matches found").done();
 			}
 
-			let outputLines: string[] = [];
+			const outputLines: string[] = [];
 			let linesTruncated = false;
+			let matchIndex = 0;
 
 			for (const match of result.matches) {
 				recordFile(match.path);
 				const relativePath = formatPath(match.path);
 
-				if (effectiveOutputMode === "content") {
-					// Add context before
-					if (match.contextBefore) {
-						for (const ctx of match.contextBefore) {
-							outputLines.push(
-								showLineNumbers
-									? `${relativePath}-${ctx.lineNumber}- ${ctx.line}`
-									: `${relativePath}- ${ctx.line}`,
-							);
-						}
+				matchIndex += 1;
+				if (matchIndex > 1) {
+					outputLines.push("");
+				}
+				outputLines.push(`${matchIndex}. ${relativePath}:${match.lineNumber}`);
+
+				const lineNumbers: number[] = [match.lineNumber];
+				if (match.contextBefore) {
+					for (const ctx of match.contextBefore) {
+						lineNumbers.push(ctx.lineNumber);
 					}
+				}
+				if (match.contextAfter) {
+					for (const ctx of match.contextAfter) {
+						lineNumbers.push(ctx.lineNumber);
+					}
+				}
+				const lineWidth = Math.max(...lineNumbers.map(value => value.toString().length));
 
-					// Add match line
-					outputLines.push(
-						showLineNumbers
-							? `${relativePath}:${match.lineNumber}: ${match.line}`
-							: `${relativePath}: ${match.line}`,
-					);
+				const formatLine = (lineNumber: number, line: string, isMatch: boolean): string => {
+					const padded = lineNumber.toString().padStart(lineWidth, " ");
+					return isMatch ? `>>${padded} ${line}` : `  ${padded} ${line}`;
+				};
 
-					if (match.truncated) {
-						linesTruncated = true;
+				// Add context before
+				if (match.contextBefore) {
+					for (const ctx of match.contextBefore) {
+						outputLines.push(formatLine(ctx.lineNumber, ctx.line, false));
 					}
+				}
 
-					// Add context after
-					if (match.contextAfter) {
-						for (const ctx of match.contextAfter) {
-							outputLines.push(
-								showLineNumbers
-									? `${relativePath}-${ctx.lineNumber}- ${ctx.line}`
-									: `${relativePath}- ${ctx.line}`,
-							);
-						}
-					}
+				// Add match line
+				outputLines.push(formatLine(match.lineNumber, match.line, true));
 
-					// Track per-file counts
-					fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
-				} else if (effectiveOutputMode === "filesWithMatches") {
-					// One line per file
-					const matchWithCount = match as WasmGrepMatch & { matchCount?: number };
-					fileMatchCounts.set(relativePath, matchWithCount.matchCount ?? 1);
-				} else {
-					// count mode
-					const matchWithCount = match as WasmGrepMatch & { matchCount?: number };
-					fileMatchCounts.set(relativePath, matchWithCount.matchCount ?? 0);
+				if (match.truncated) {
+					linesTruncated = true;
 				}
-			}
 
-			// Format output based on mode
-			if (effectiveOutputMode === "filesWithMatches") {
-				outputLines = fileList;
-			} else if (effectiveOutputMode === "count") {
-				outputLines = fileList.map(f => `${f}:${fileMatchCounts.get(f) ?? 0}`);
+				// Add context after
+				if (match.contextAfter) {
+					for (const ctx of match.contextAfter) {
+						outputLines.push(formatLine(ctx.lineNumber, ctx.line, false));
+					}
+				}
+
+				// Track per-file counts
+				fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
 			}
 
 			const rawOutput = outputLines.join("\n");
@@ -261,7 +253,6 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 					path,
 					count: fileMatchCounts.get(path) ?? 0,
 				})),
-				mode: effectiveOutputMode,
 				truncated,
 				matchLimitReached: result.limitReached ? effectiveLimit : undefined,
 			};
@@ -295,15 +286,13 @@ interface GrepRenderArgs {
 	glob?: string;
 	type?: string;
 	i?: boolean;
-	n?: boolean;
-	context?: number;
+	pre?: number;
+	post?: number;
 	multiline?: boolean;
-	output_mode?: string;
 	limit?: number;
 	offset?: number;
 }
 
-const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
 const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
 
 export const grepToolRenderer = {
@@ -313,10 +302,13 @@ export const grepToolRenderer = {
 		if (args.path) meta.push(`in ${args.path}`);
 		if (args.glob) meta.push(`glob:${args.glob}`);
 		if (args.type) meta.push(`type:${args.type}`);
-		if (args.output_mode && args.output_mode !== "filesWithMatches") meta.push(`mode:${args.output_mode}`);
 		if (args.i) meta.push("case:insensitive");
-		if (args.n === false) meta.push("no-line-numbers");
-		if (args.context !== undefined && args.context > 0) meta.push(`context:${args.context}`);
+		if (args.pre !== undefined && args.pre > 0) {
+			meta.push(`pre:${args.pre}`);
+		}
+		if (args.post !== undefined && args.post > 0) {
+			meta.push(`post:${args.post}`);
+		}
 		if (args.multiline) meta.push("multiline");
 		if (args.limit !== undefined && args.limit > 0) meta.push(`limit:${args.limit}`);
 		if (args.offset !== undefined && args.offset > 0) meta.push(`offset:${args.offset}`);
@@ -369,13 +361,11 @@ export const grepToolRenderer = {
 
 		const matchCount = details?.matchCount ?? 0;
 		const fileCount = details?.fileCount ?? 0;
-		const mode = details?.mode ?? "filesWithMatches";
 		const truncation = details?.meta?.truncation;
 		const limits = details?.meta?.limits;
 		const truncated = Boolean(
 			details?.truncated || truncation || limits?.matchLimit || limits?.resultLimit || limits?.columnTruncated,
 		);
-		const files = details?.files ?? [];
 
 		if (matchCount === 0) {
 			const header = renderStatusLine(
@@ -385,10 +375,7 @@ export const grepToolRenderer = {
 			return new Text([header, formatEmptyMessage("No matches found", uiTheme)].join("\n"), 0, 0);
 		}
 
-		const summaryParts =
-			mode === "filesWithMatches"
-				? [formatCount("file", fileCount)]
-				: [formatCount("match", matchCount), formatCount("file", fileCount)];
+		const summaryParts = [formatCount("match", matchCount), formatCount("file", fileCount)];
 		const meta = [...summaryParts];
 		if (details?.scopePath) meta.push(`in ${details.scopePath}`);
 		if (truncated) meta.push(uiTheme.fg("warning", "truncated"));
@@ -398,34 +385,51 @@ export const grepToolRenderer = {
 			uiTheme,
 		);
 
-		if (mode === "content") {
-			const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
-			const contentLines = textContent.split("\n").filter(line => line.trim().length > 0);
-			const matchLines = renderTreeList(
-				{
-					items: contentLines,
-					expanded,
-					maxCollapsed: COLLAPSED_TEXT_LIMIT,
-					itemType: "match",
-					renderItem: line => uiTheme.fg("toolOutput", line),
-				},
-				uiTheme,
-			);
-			return new Text([header, ...matchLines].join("\n"), 0, 0);
+		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
+		const rawLines = textContent.split("\n");
+		const hasSeparators = rawLines.some(line => line.trim().length === 0);
+		const matchGroups: string[][] = [];
+		if (hasSeparators) {
+			let current: string[] = [];
+			for (const line of rawLines) {
+				if (line.trim().length === 0) {
+					if (current.length > 0) {
+						matchGroups.push(current);
+						current = [];
+					}
+					continue;
+				}
+				current.push(line);
+			}
+			if (current.length > 0) matchGroups.push(current);
+		} else {
+			for (const line of rawLines) {
+				if (line.trim().length === 0) continue;
+				matchGroups.push([line]);
+			}
 		}
 
-		const fileEntries: Array<{ path: string; count?: number }> = details?.fileMatches?.length
-			? details.fileMatches.map(entry => ({ path: entry.path, count: entry.count }))
-			: files.map(path => ({ path }));
-		const fileLines = renderFileList(
+		const getCollapsedMatchLimit = (groups: string[][], maxLines: number): number => {
+			if (groups.length === 0) return 0;
+			let usedLines = 0;
+			let count = 0;
+			for (const group of groups) {
+				if (count > 0 && usedLines + group.length > maxLines) break;
+				usedLines += group.length;
+				count += 1;
+				if (usedLines >= maxLines) break;
+			}
+			return count;
+		};
+
+		const maxCollapsed = expanded ? matchGroups.length : getCollapsedMatchLimit(matchGroups, COLLAPSED_TEXT_LIMIT);
+		const matchLines = renderTreeList(
 			{
-				files: fileEntries.map(entry => ({
-					path: entry.path,
-					isDirectory: entry.path.endsWith("/"),
-					meta: entry.count !== undefined ? `(${entry.count} match${entry.count !== 1 ? "es" : ""})` : undefined,
-				})),
+				items: matchGroups,
 				expanded,
-				maxCollapsed: COLLAPSED_LIST_LIMIT,
+				maxCollapsed,
+				itemType: "match",
+				renderItem: group => group.map(line => uiTheme.fg("toolOutput", line)),
 			},
 			uiTheme,
 		);
@@ -440,7 +444,7 @@ export const grepToolRenderer = {
 		const extraLines =
 			truncationReasons.length > 0 ? [uiTheme.fg("warning", `truncated: ${truncationReasons.join(", ")}`)] : [];
 
-		return new Text([header, ...fileLines, ...extraLines].join("\n"), 0, 0);
+		return new Text([header, ...matchLines, ...extraLines].join("\n"), 0, 0);
 	},
 	mergeCallAndResult: true,
 };

package/src/tools/index.ts

@@ -17,6 +17,7 @@ import { time } from "../utils/timings";
 import { WebSearchTool } from "../web/search";
 import { AskTool } from "./ask";
 import { BashTool } from "./bash";
+import { BrowserTool } from "./browser";
 import { CalculatorTool } from "./calculator";
 import { ExitPlanModeTool } from "./exit-plan-mode";
 import { FetchTool } from "./fetch";
@@ -69,6 +70,7 @@ export {
 } from "../web/search";
 export { AskTool, type AskToolDetails } from "./ask";
 export { BashTool, type BashToolDetails, type BashToolOptions } from "./bash";
+export { BrowserTool, type BrowserToolDetails } from "./browser";
 export { CalculatorTool, type CalculatorToolDetails } from "./calculator";
 export { type ExitPlanModeDetails, ExitPlanModeTool } from "./exit-plan-mode";
 export { FetchTool, type FetchToolDetails } from "./fetch";
@@ -171,6 +173,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	lsp: LspTool.createIf,
 	notebook: s => new NotebookTool(s),
 	read: s => new ReadTool(s),
+	browser: s => new BrowserTool(s),
 	task: TaskTool.create,
 	todo_write: s => new TodoWriteTool(s),
 	fetch: s => new FetchTool(s),
@@ -283,6 +286,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "web_search") return session.settings.get("web_search.enabled");
 		if (name === "lsp") return session.settings.get("lsp.enabled");
 		if (name === "calc") return session.settings.get("calc.enabled");
+		if (name === "browser") return session.settings.get("browser.enabled");
 		return true;
 	};
 	if (includeSubmitResult && requestedTools && !requestedTools.includes("submit_result")) {

package/src/tools/json-tree.ts

@@ -0,0 +1,231 @@
+/**
+ * JSON tree rendering utilities shared across tool renderers.
+ */
+import type { Theme } from "../modes/theme/theme";
+import { truncateToWidth } from "./render-utils";
+
+/** Max depth for JSON tree rendering */
+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;
+
+/**
+ * Format a scalar value for inline display.
+ */
+export function formatScalar(value: unknown, maxLen: number): string {
+	if (value === null) return "null";
+	if (value === undefined) return "undefined";
+	if (typeof value === "boolean") return String(value);
+	if (typeof value === "number") return String(value);
+	if (typeof value === "string") {
+		const escaped = value.replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+		const truncated = truncateToWidth(escaped, maxLen);
+		return `"${truncated}"`;
+	}
+	if (Array.isArray(value)) return `[${value.length} items]`;
+	if (typeof value === "object") {
+		const keys = Object.keys(value);
+		return `{${keys.length} keys}`;
+	}
+	return String(value);
+}
+
+/**
+ * Format args inline for collapsed view.
+ */
+export function formatArgsInline(args: Record<string, unknown>, maxWidth: number): string {
+	const entries = Object.entries(args);
+	if (entries.length === 0) return "";
+
+	// Single arg: show key=value
+	if (entries.length === 1) {
+		const [key, value] = entries[0];
+		return `${key}=${formatScalar(value, maxWidth - key.length - 1)}`;
+	}
+
+	// Multiple args: show key=value, key=value...
+	const pairs: string[] = [];
+	let totalLen = 0;
+
+	for (const [key, value] of entries) {
+		const valueStr = formatScalar(value, 24);
+		const pairStr = `${key}=${valueStr}`;
+		const addLen = pairs.length > 0 ? pairStr.length + 2 : pairStr.length;
+
+		if (totalLen + addLen > maxWidth && pairs.length > 0) {
+			pairs.push("…");
+			break;
+		}
+
+		pairs.push(pairStr);
+		totalLen += addLen;
+	}
+
+	return pairs.join(", ");
+}
+
+/**
+ * Build tree prefix for nested rendering.
+ */
+function buildTreePrefix(ancestors: boolean[], theme: Theme): string {
+	return ancestors.map(hasNext => (hasNext ? `${theme.tree.vertical}  ` : "   ")).join("");
+}
+
+/**
+ * Render a JSON value as tree lines.
+ */
+export function renderJsonTreeLines(
+	value: unknown,
+	theme: Theme,
+	maxDepth: number,
+	maxLines: number,
+	maxScalarLen: number,
+): { lines: string[]; truncated: boolean } {
+	const lines: string[] = [];
+	let truncated = false;
+
+	const iconObject = theme.styledSymbol("icon.folder", "muted");
+	const iconArray = theme.styledSymbol("icon.package", "muted");
+	const iconScalar = theme.styledSymbol("icon.file", "muted");
+
+	const pushLine = (line: string): boolean => {
+		if (lines.length >= maxLines) {
+			truncated = true;
+			return false;
+		}
+		lines.push(line);
+		return true;
+	};
+
+	const renderNode = (val: unknown, key: string | undefined, ancestors: boolean[], isLast: boolean, depth: number) => {
+		if (lines.length >= maxLines) {
+			truncated = true;
+			return;
+		}
+
+		const connector = isLast ? theme.tree.last : theme.tree.branch;
+		const prefix = `${buildTreePrefix(ancestors, theme)}${theme.fg("dim", connector)} `;
+
+		// Handle scalars
+		if (val === null || val === undefined || typeof val !== "object") {
+			const label = key ? theme.fg("muted", key) : theme.fg("muted", "value");
+
+			// Special handling for multiline strings
+			if (typeof val === "string" && val.includes("\n")) {
+				const strLines = val.split("\n");
+				const maxStrLines = Math.min(strLines.length, Math.max(1, maxLines - lines.length - 1));
+				const continuePrefix = buildTreePrefix([...ancestors, !isLast], theme);
+
+				// First line with label
+				const firstLine = truncateToWidth(strLines[0], maxScalarLen);
+				pushLine(`${prefix}${iconScalar} ${label}: ${theme.fg("dim", `"${firstLine}`)}`);
+
+				// Subsequent lines indented
+				for (let i = 1; i < maxStrLines; i++) {
+					if (lines.length >= maxLines) {
+						truncated = true;
+						break;
+					}
+					const line = truncateToWidth(strLines[i], maxScalarLen);
+					pushLine(`${continuePrefix}   ${theme.fg("dim", ` ${line}`)}`);
+				}
+
+				// Show truncation and closing quote
+				if (strLines.length > maxStrLines) {
+					truncated = true;
+					pushLine(`${continuePrefix}   ${theme.fg("dim", ` …(${strLines.length - maxStrLines} more lines)"`)}`);
+				} else {
+					// Add closing quote to last line - need to modify the last pushed line
+					const lastIdx = lines.length - 1;
+					lines[lastIdx] = `${lines[lastIdx]}${theme.fg("dim", '"')}`;
+				}
+				return;
+			}
+
+			const scalar = formatScalar(val, maxScalarLen);
+			pushLine(`${prefix}${iconScalar} ${label}: ${theme.fg("dim", scalar)}`);
+			return;
+		}
+
+		// Handle arrays
+		if (Array.isArray(val)) {
+			const header = key ? theme.fg("muted", key) : theme.fg("muted", "array");
+			pushLine(`${prefix}${iconArray} ${header}`);
+			if (val.length === 0) {
+				pushLine(
+					`${buildTreePrefix([...ancestors, !isLast], theme)}${theme.fg("dim", theme.tree.last)} ${theme.fg("dim", "[]")}`,
+				);
+				return;
+			}
+			if (depth >= maxDepth) {
+				pushLine(
+					`${buildTreePrefix([...ancestors, !isLast], theme)}${theme.fg("dim", theme.tree.last)} ${theme.fg("dim", "…")}`,
+				);
+				return;
+			}
+			const nextAncestors = [...ancestors, !isLast];
+			for (let i = 0; i < val.length; i++) {
+				renderNode(val[i], `[${i}]`, nextAncestors, i === val.length - 1, depth + 1);
+				if (lines.length >= maxLines) {
+					truncated = true;
+					return;
+				}
+			}
+			return;
+		}
+
+		// Handle objects
+		const header = key ? theme.fg("muted", key) : theme.fg("muted", "object");
+		pushLine(`${prefix}${iconObject} ${header}`);
+		const entries = Object.entries(val as Record<string, unknown>);
+		if (entries.length === 0) {
+			pushLine(
+				`${buildTreePrefix([...ancestors, !isLast], theme)}${theme.fg("dim", theme.tree.last)} ${theme.fg("dim", "{}")}`,
+			);
+			return;
+		}
+		if (depth >= maxDepth) {
+			pushLine(
+				`${buildTreePrefix([...ancestors, !isLast], theme)}${theme.fg("dim", theme.tree.last)} ${theme.fg("dim", "…")}`,
+			);
+			return;
+		}
+		const nextAncestors = [...ancestors, !isLast];
+		for (let i = 0; i < entries.length; i++) {
+			const [childKey, child] = entries[i];
+			renderNode(child, childKey, nextAncestors, i === entries.length - 1, depth + 1);
+			if (lines.length >= maxLines) {
+				truncated = true;
+				return;
+			}
+		}
+	};
+
+	// Render root level
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const entries = Object.entries(value as Record<string, unknown>);
+		for (let i = 0; i < entries.length; i++) {
+			const [childKey, child] = entries[i];
+			renderNode(child, childKey, [], i === entries.length - 1, 1);
+			if (lines.length >= maxLines) {
+				truncated = true;
+				break;
+			}
+		}
+	} else if (Array.isArray(value)) {
+		for (let i = 0; i < value.length; i++) {
+			renderNode(value[i], `[${i}]`, [], i === value.length - 1, 1);
+			if (lines.length >= maxLines) {
+				truncated = true;
+				break;
+			}
+		}
+	} else {
+		renderNode(value, undefined, [], true, 0);
+	}
+
+	return { lines, truncated };
+}

package/src/tools/notebook.ts

@@ -65,6 +65,7 @@ export class NotebookTool implements AgentTool<typeof notebookSchema, NotebookTo
 	public readonly description =
 		"Completely replaces the contents of a specific cell in a Jupyter notebook (.ipynb file) with new source. Jupyter notebooks are interactive documents that combine code, text, and visualizations, commonly used for data analysis and scientific computing. The notebook_path parameter must be an absolute path, not a relative path. The cell_number is 0-indexed. Use edit_mode=insert to add a new cell at the index specified by cell_number. Use edit_mode=delete to delete the cell at the index specified by cell_number.";
 	public readonly parameters = notebookSchema;
+	public readonly concurrency = "exclusive";
 
 	private readonly session: ToolSession;