@oh-my-pi/pi-coding-agent 13.3.6 → 13.3.8

package/src/tools/ast-replace.ts

@@ -0,0 +1,294 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { astReplace } 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";
+import { type Static, Type } from "@sinclair/typebox";
+import { renderPromptTemplate } from "../config/prompt-templates";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import astReplaceDescription from "../prompts/tools/ast-replace.md" with { type: "text" };
+import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
+import type { ToolSession } from ".";
+import type { OutputMeta } from "./output-meta";
+import { hasGlobPathChars, parseSearchPath, resolveToCwd } from "./path-utils";
+import { formatCount, formatEmptyMessage, formatErrorMessage, PREVIEW_LIMITS } from "./render-utils";
+import { ToolError } from "./tool-errors";
+import { toolResult } from "./tool-result";
+
+const astReplaceSchema = Type.Object({
+	pattern: Type.String({ description: "AST pattern to match" }),
+	rewrite: Type.String({ description: "Rewrite template" }),
+	lang: Type.Optional(Type.String({ description: "Language override" })),
+	path: Type.Optional(Type.String({ description: "File, directory, or glob pattern to rewrite (default: cwd)" })),
+	selector: Type.Optional(Type.String({ description: "Optional selector for contextual pattern mode" })),
+	dry_run: Type.Optional(Type.Boolean({ description: "Preview only (default: true)" })),
+	max_replacements: Type.Optional(Type.Number({ description: "Safety cap on total replacements" })),
+	max_files: Type.Optional(Type.Number({ description: "Safety cap on touched files" })),
+});
+
+export interface AstReplaceToolDetails {
+	totalReplacements: number;
+	filesTouched: number;
+	filesSearched: number;
+	applied: boolean;
+	limitReached: boolean;
+	parseErrors?: string[];
+	meta?: OutputMeta;
+}
+
+export class AstReplaceTool implements AgentTool<typeof astReplaceSchema, AstReplaceToolDetails> {
+	readonly name = "ast_replace";
+	readonly label = "AST Replace";
+	readonly description: string;
+	readonly parameters = astReplaceSchema;
+	readonly strict = true;
+
+	constructor(private readonly session: ToolSession) {
+		this.description = renderPromptTemplate(astReplaceDescription);
+	}
+
+	async execute(
+		_toolCallId: string,
+		params: Static<typeof astReplaceSchema>,
+		signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<AstReplaceToolDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<AstReplaceToolDetails>> {
+		return untilAborted(signal, async () => {
+			const pattern = params.pattern?.trim();
+			if (!pattern) {
+				throw new ToolError("`pattern` is required");
+			}
+			if (!params.rewrite?.trim()) {
+				throw new ToolError("`rewrite` is required");
+			}
+
+			const maxReplacements =
+				params.max_replacements === undefined ? undefined : Math.floor(params.max_replacements);
+			if (maxReplacements !== undefined && (!Number.isFinite(maxReplacements) || maxReplacements < 1)) {
+				throw new ToolError("max_replacements must be a positive number");
+			}
+			const maxFiles = params.max_files === undefined ? undefined : Math.floor(params.max_files);
+			if (maxFiles !== undefined && (!Number.isFinite(maxFiles) || maxFiles < 1)) {
+				throw new ToolError("max_files must be a positive number");
+			}
+
+			let searchPath: string | undefined;
+			let globFilter: string | undefined;
+			const rawPath = params.path?.trim();
+			if (rawPath) {
+				const internalRouter = this.session.internalRouter;
+				if (internalRouter?.canHandle(rawPath)) {
+					if (hasGlobPathChars(rawPath)) {
+						throw new ToolError(`Glob patterns are not supported for internal URLs: ${rawPath}`);
+					}
+					const resource = await internalRouter.resolve(rawPath);
+					if (!resource.sourcePath) {
+						throw new ToolError(`Cannot rewrite internal URL without backing file: ${rawPath}`);
+					}
+					searchPath = resource.sourcePath;
+				} else {
+					const parsedPath = parseSearchPath(rawPath);
+					searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
+					globFilter = parsedPath.glob;
+				}
+			}
+
+			const result = await astReplace({
+				pattern,
+				rewrite: params.rewrite?.trim(),
+				lang: params.lang?.trim(),
+				path: searchPath,
+				glob: globFilter,
+				selector: params.selector?.trim(),
+				dryRun: params.dry_run,
+				maxReplacements,
+				maxFiles,
+				failOnParseError: false,
+				signal,
+			});
+
+			const details: AstReplaceToolDetails = {
+				totalReplacements: result.totalReplacements,
+				filesTouched: result.filesTouched,
+				filesSearched: result.filesSearched,
+				applied: result.applied,
+				limitReached: result.limitReached,
+				parseErrors: result.parseErrors,
+			};
+
+			const action = result.applied ? "Applied" : "Would apply";
+			const lines = [
+				`${action} ${result.totalReplacements} replacements across ${result.filesTouched} files (searched ${result.filesSearched})`,
+			];
+			if (result.fileChanges.length > 0) {
+				lines.push("", "File changes:");
+				for (const file of result.fileChanges) {
+					lines.push(`- ${file.path}: ${file.count}`);
+				}
+			}
+			if (result.changes.length > 0) {
+				lines.push("", "Preview:");
+				for (const change of result.changes.slice(0, 30)) {
+					const before = (change.before.split("\n", 1)[0] ?? "").slice(0, 80);
+					const after = (change.after.split("\n", 1)[0] ?? "").slice(0, 80);
+					lines.push(`${change.path}:${change.startLine}:${change.startColumn} ${before} -> ${after}`);
+				}
+				if (result.changes.length > 30) {
+					lines.push(`... ${result.changes.length - 30} more changes`);
+				}
+			}
+			if (result.limitReached) {
+				lines.push("", "Safety cap reached; narrow path pattern or increase max_files/max_replacements.");
+			}
+			if (result.parseErrors?.length) {
+				lines.push("", "Parse issues:", ...result.parseErrors.map(err => `- ${err}`));
+			}
+
+			return toolResult(details).text(lines.join("\n")).done();
+		});
+	}
+}
+
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface AstReplaceRenderArgs {
+	pattern?: string;
+	rewrite?: string;
+	lang?: string;
+	path?: string;
+	selector?: string;
+	dry_run?: boolean;
+	max_replacements?: number;
+	max_files?: number;
+	fail_on_parse_error?: boolean;
+}
+
+const COLLAPSED_CHANGE_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
+
+export const astReplaceToolRenderer = {
+	inline: true,
+	renderCall(args: AstReplaceRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+		const meta: string[] = [];
+		if (args.lang) meta.push(`lang:${args.lang}`);
+		if (args.path) meta.push(`in ${args.path}`);
+		if (args.dry_run !== false) meta.push("dry run");
+		if (args.max_replacements !== undefined) meta.push(`max:${args.max_replacements}`);
+		if (args.max_files !== undefined) meta.push(`max files:${args.max_files}`);
+
+		const description = args.pattern || "?";
+		const text = renderStatusLine({ icon: "pending", title: "AST Replace", description, meta }, uiTheme);
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: AstReplaceToolDetails; isError?: boolean },
+		options: RenderResultOptions,
+		uiTheme: Theme,
+		args?: AstReplaceRenderArgs,
+	): Component {
+		const details = result.details;
+
+		if (result.isError) {
+			const errorText = result.content?.find(c => c.type === "text")?.text || "Unknown error";
+			return new Text(formatErrorMessage(errorText, uiTheme), 0, 0);
+		}
+
+		const totalReplacements = details?.totalReplacements ?? 0;
+		const filesTouched = details?.filesTouched ?? 0;
+		const filesSearched = details?.filesSearched ?? 0;
+		const applied = details?.applied ?? false;
+		const limitReached = details?.limitReached ?? false;
+
+		if (totalReplacements === 0) {
+			const description = args?.pattern;
+			const meta = ["0 replacements"];
+			if (filesSearched > 0) meta.push(`searched ${filesSearched}`);
+			const header = renderStatusLine({ icon: "warning", title: "AST Replace", description, meta }, uiTheme);
+			return new Text([header, formatEmptyMessage("No replacements made", uiTheme)].join("\n"), 0, 0);
+		}
+
+		const summaryParts = [
+			formatCount("replacement", totalReplacements),
+			formatCount("file", filesTouched),
+			`searched ${filesSearched}`,
+		];
+		const meta = [...summaryParts];
+		if (limitReached) meta.push(uiTheme.fg("warning", "limit reached"));
+		const description = args?.pattern;
+		const badge = applied
+			? { label: "applied", color: "success" as const }
+			: { label: "dry run", color: "warning" as const };
+		const header = renderStatusLine(
+			{ icon: limitReached ? "warning" : "success", title: "AST Replace", description, badge, meta },
+			uiTheme,
+		);
+
+		// Parse text content into display groups
+		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
+		const rawLines = textContent.split("\n");
+		// Skip the summary line and group by blank-line separators
+		const contentLines = rawLines.slice(1);
+		const allGroups: string[][] = [];
+		let current: string[] = [];
+		for (const line of contentLines) {
+			if (line.trim().length === 0) {
+				if (current.length > 0) {
+					allGroups.push(current);
+					current = [];
+				}
+				continue;
+			}
+			current.push(line);
+		}
+		if (current.length > 0) allGroups.push(current);
+
+		// Filter out trailing metadata groups (safety cap / parse issues) — shown via details
+		const displayGroups = allGroups.filter(
+			group => !group[0]?.startsWith("Safety cap") && !group[0]?.startsWith("Parse issues"),
+		);
+
+		const extraLines: string[] = [];
+		if (limitReached) {
+			extraLines.push(uiTheme.fg("warning", "safety cap reached; narrow scope or increase limits"));
+		}
+		if (details?.parseErrors?.length) {
+			extraLines.push(uiTheme.fg("warning", `${details.parseErrors.length} parse issue(s)`));
+		}
+
+		let cached: RenderCache | undefined;
+		return {
+			render(width: number): string[] {
+				const { expanded } = options;
+				const key = new Hasher().bool(expanded).u32(width).digest();
+				if (cached?.key === key) return cached.lines;
+				const matchLines = renderTreeList(
+					{
+						items: displayGroups,
+						expanded,
+						maxCollapsed: expanded ? displayGroups.length : COLLAPSED_CHANGE_LIMIT,
+						itemType: "section",
+						renderItem: group =>
+							group.map(line => {
+								if (line === "File changes:" || line === "Preview:") return uiTheme.fg("accent", line);
+								if (line.startsWith("- ")) return uiTheme.fg("toolOutput", line);
+								if (line.startsWith("...")) return uiTheme.fg("dim", line);
+								return uiTheme.fg("toolOutput", line);
+							}),
+					},
+					uiTheme,
+				);
+				const result = [header, ...matchLines, ...extraLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
+				cached = { key, lines: result };
+				return result;
+			},
+			invalidate() {
+				cached = undefined;
+			},
+		};
+	},
+	mergeCallAndResult: true,
+};

package/src/tools/bash.ts

@@ -25,6 +25,7 @@ import { resolveToCwd } from "./path-utils";
 import { replaceTabs } from "./render-utils";
 import { ToolAbortError, ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
+import { clampTimeout } from "./tool-timeouts";
 
 export const BASH_DEFAULT_PREVIEW_LINES = 10;
 
@@ -200,7 +201,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		}
 
 		// Clamp to reasonable range: 1s - 3600s (1 hour)
-		const timeoutSec = Math.max(1, Math.min(3600, rawTimeout));
+		const timeoutSec = clampTimeout("bash", rawTimeout);
 		const timeoutMs = timeoutSec * 1000;
 
 		if (asyncRequested) {

package/src/tools/browser.ts

@@ -37,6 +37,7 @@ import stealthCodecsScript from "./puppeteer/12_stealth_codecs.txt" with { type:
 import stealthWorkerScript from "./puppeteer/13_stealth_worker.txt" with { type: "text" };
 import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
+import { clampTimeout } from "./tool-timeouts";
 
 /**
  * Lazy-import puppeteer from a safe CWD so cosmiconfig doesn't choke
@@ -57,8 +58,6 @@ async function loadPuppeteer(): Promise<typeof Puppeteer> {
 	}
 }
 
-const DEFAULT_TIMEOUT_SECONDS = 30;
-const MAX_TIMEOUT_SECONDS = 120;
 const DEFAULT_VIEWPORT = { width: 1365, height: 768, deviceScaleFactor: 1.25 };
 const STEALTH_IGNORE_DEFAULT_ARGS = [
 	"--disable-extensions",
@@ -452,11 +451,6 @@ export interface ReadableResult {
 	markdown?: string;
 }
 
-function clampTimeout(timeoutSeconds?: number): number {
-	if (timeoutSeconds === undefined) return DEFAULT_TIMEOUT_SECONDS;
-	return Math.min(Math.max(timeoutSeconds, 1), MAX_TIMEOUT_SECONDS);
-}
-
 function ensureParam<T>(value: T | undefined, name: string, action: string): T {
 	if (value === undefined || value === null || value === "") {
 		throw new ToolError(`Missing required parameter '${name}' for action '${action}'.`);
@@ -956,7 +950,7 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 	): Promise<AgentToolResult<BrowserToolDetails>> {
 		try {
 			throwIfAborted(signal);
-			const timeoutSeconds = clampTimeout(params.timeout);
+			const timeoutSeconds = clampTimeout("browser", params.timeout);
 			const timeoutMs = timeoutSeconds * 1000;
 			const details: BrowserToolDetails = { action: params.action };
 

package/src/tools/fetch.ts

@@ -5,7 +5,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { ptree, truncate } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { parse as parseHtml } from "node-html-parser";
+import { parseHTML } from "linkedom";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme, theme } from "../modes/theme/theme";
@@ -24,6 +24,7 @@ import { formatStyledArtifactReference, type OutputMeta } from "./output-meta";
 import { formatExpandHint, getDomain } from "./render-utils";
 import { ToolAbortError } from "./tool-errors";
 import { toolResult } from "./tool-result";
+import { clampTimeout } from "./tool-timeouts";
 
 // =============================================================================
 // Types and Constants
@@ -248,6 +249,36 @@ async function tryContentNegotiation(
 	return null;
 }
 
+/**
+ * Read a single HTML attribute from a tag string
+ */
+function getHtmlAttribute(tag: string, attribute: string): string | null {
+	const pattern = new RegExp(`\\b${attribute}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'=<>]+))`, "i");
+	const match = tag.match(pattern);
+	if (!match) return null;
+	return (match[1] ?? match[2] ?? match[3] ?? "").trim();
+}
+
+/**
+ * Extract bounded <head> markup to avoid expensive whole-page parsing
+ */
+function extractHeadHtml(html: string): string {
+	const lower = html.toLowerCase();
+	const headStart = lower.indexOf("<head");
+	if (headStart === -1) {
+		return html.slice(0, 32 * 1024);
+	}
+
+	const headTagEnd = html.indexOf(">", headStart);
+	if (headTagEnd === -1) {
+		return html.slice(headStart, headStart + 32 * 1024);
+	}
+
+	const headEnd = lower.indexOf("</head>", headTagEnd + 1);
+	const fallbackEnd = Math.min(html.length, headTagEnd + 1 + 32 * 1024);
+	return html.slice(headStart, headEnd === -1 ? fallbackEnd : headEnd + 7);
+}
+
 /**
  * Parse alternate links from HTML head
  */
@@ -255,13 +286,17 @@ function parseAlternateLinks(html: string, pageUrl: string): string[] {
 	const links: string[] = [];
 
 	try {
-		const doc = parseHtml(html.slice(0, 262144));
-		const alternateLinks = doc.querySelectorAll('link[rel="alternate"]');
+		const pagePath = new URL(pageUrl).pathname;
+		const headHtml = extractHeadHtml(html);
+		const linkTags = headHtml.match(/<link\b[^>]*>/gi) ?? [];
 
-		for (const link of alternateLinks) {
-			const href = link.getAttribute("href");
-			const type = link.getAttribute("type")?.toLowerCase() ?? "";
+		for (const tag of linkTags) {
+			const rel = getHtmlAttribute(tag, "rel")?.toLowerCase() ?? "";
+			const relTokens = rel.split(/\s+/).filter(Boolean);
+			if (!relTokens.includes("alternate")) continue;
 
+			const href = getHtmlAttribute(tag, "href");
+			const type = getHtmlAttribute(tag, "type")?.toLowerCase() ?? "";
 			if (!href) continue;
 
 			// Skip site-wide feeds
@@ -278,7 +313,7 @@ function parseAlternateLinks(html: string, pageUrl: string): string[] {
 				links.push(href);
 			} else if (
 				(type.includes("rss") || type.includes("atom") || type.includes("feed")) &&
-				(href.includes(new URL(pageUrl).pathname) || href.includes("comments"))
+				(href.includes(pagePath) || href.includes("comments"))
 			) {
 				links.push(href);
 			}
@@ -293,20 +328,22 @@ function parseAlternateLinks(html: string, pageUrl: string): string[] {
  */
 function extractDocumentLinks(html: string, baseUrl: string): string[] {
 	const links: string[] = [];
+	const seen = new Set<string>();
 
 	try {
-		const doc = parseHtml(html);
-		const anchors = doc.querySelectorAll("a[href]");
-
-		for (const anchor of anchors) {
-			const href = anchor.getAttribute("href");
+		const anchorTags = html.slice(0, 512 * 1024).match(/<a\b[^>]*>/gi) ?? [];
+		for (const tag of anchorTags) {
+			const href = getHtmlAttribute(tag, "href");
 			if (!href) continue;
 
 			const ext = path.extname(href).toLowerCase();
-			if (CONVERTIBLE_EXTENSIONS.has(ext)) {
-				const resolved = href.startsWith("http") ? href : new URL(href, baseUrl).href;
-				links.push(resolved);
-			}
+			if (!CONVERTIBLE_EXTENSIONS.has(ext)) continue;
+
+			const resolved = href.startsWith("http") ? href : new URL(href, baseUrl).href;
+			if (seen.has(resolved)) continue;
+			seen.add(resolved);
+			links.push(resolved);
+			if (links.length >= 20) break;
 		}
 	} catch {}
 
@@ -333,7 +370,7 @@ function cleanFeedText(text: string): string {
  */
 function parseFeedToMarkdown(content: string, maxItems = 10): string {
 	try {
-		const doc = parseHtml(content, { parseNoneClosedTags: true });
+		const doc = parseHTML(content).document;
 
 		// Try RSS
 		const channel = doc.querySelector("channel");
@@ -872,7 +909,7 @@ export class FetchTool implements AgentTool<typeof fetchSchema, FetchToolDetails
 		const { url, timeout: rawTimeout = 20, raw = false } = params;
 
 		// Clamp to valid range (seconds)
-		const effectiveTimeout = Math.min(Math.max(rawTimeout, 1), 45);
+		const effectiveTimeout = clampTimeout("fetch", rawTimeout);
 
 		if (signal?.aborted) {
 			throw new ToolAbortError();

package/src/tools/index.ts

@@ -15,6 +15,8 @@ import type { AgentOutputManager } from "../task/output-manager";
 import type { EventBus } from "../utils/event-bus";
 import { SearchTool } from "../web/search";
 import { AskTool } from "./ask";
+import { AstFindTool } from "./ast-find";
+import { AstReplaceTool } from "./ast-replace";
 import { AwaitTool } from "./await-tool";
 import { BashTool } from "./bash";
 import { BrowserTool } from "./browser";
@@ -54,6 +56,8 @@ export * from "../session/streaming-output";
 export { BUNDLED_AGENTS, TaskTool } from "../task";
 export * from "../web/search";
 export { AskTool, type AskToolDetails } from "./ask";
+export { AstFindTool, type AstFindToolDetails } from "./ast-find";
+export { AstReplaceTool, type AstReplaceToolDetails } from "./ast-replace";
 export { AwaitTool, type AwaitToolDetails } from "./await-tool";
 export { BashTool, type BashToolDetails, type BashToolInput, type BashToolOptions } from "./bash";
 export { BrowserTool, type BrowserToolDetails } from "./browser";
@@ -155,6 +159,8 @@ export interface ToolSession {
 type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
 
 export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
+	ast_find: s => new AstFindTool(s),
+	ast_replace: s => new AstReplaceTool(s),
 	ask: AskTool.createIf,
 	bash: s => new BashTool(s),
 	python: s => new PythonTool(s),
@@ -283,6 +289,8 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "todo_write") return !includeSubmitResult && session.settings.get("todo.enabled");
 		if (name === "find") return session.settings.get("find.enabled");
 		if (name === "grep") return session.settings.get("grep.enabled");
+		if (name === "ast_find") return session.settings.get("astFind.enabled");
+		if (name === "ast_replace") return session.settings.get("astReplace.enabled");
 		if (name === "notebook") return session.settings.get("notebook.enabled");
 		if (name === "fetch") return session.settings.get("fetch.enabled");
 		if (name === "web_search") return session.settings.get("web_search.enabled");

package/src/tools/jtd-to-json-schema.ts

@@ -38,15 +38,6 @@ function convertSchema(schema: unknown): unknown {
 		return {};
 	}
 
-	// Type form: { type: "string" } → { type: "string" }
-	if (isJTDType(schema)) {
-		const jsonType = primitiveMap[schema.type as JTDPrimitive];
-		if (!jsonType) {
-			return { type: schema.type };
-		}
-		return { type: jsonType };
-	}
-
 	// Enum form: { enum: ["a", "b"] } → { enum: ["a", "b"] }
 	if (isJTDEnum(schema)) {
 		return { enum: schema.enum };
@@ -60,6 +51,14 @@ function convertSchema(schema: unknown): unknown {
 		};
 	}
 
+	// Type form: { type: "string" } → { type: "string" }
+	if (isJTDType(schema)) {
+		const jsonType = primitiveMap[schema.type as JTDPrimitive];
+		if (!jsonType) {
+			return { type: schema.type };
+		}
+		return { type: jsonType };
+	}
 	// Values form: { values: { type: "string" } } → { type: "object", additionalProperties: ... }
 	if (isJTDValues(schema)) {
 		return {
@@ -171,13 +170,30 @@ export function isJTDSchema(schema: unknown): boolean {
 	return false;
 }
 
+function normalizeMixedSchemaNode(schema: unknown): unknown {
+	if (schema === null || typeof schema !== "object") {
+		return schema;
+	}
+
+	if (Array.isArray(schema)) {
+		return schema.map(item => normalizeMixedSchemaNode(item));
+	}
+
+	if (isJTDSchema(schema)) {
+		return normalizeMixedSchemaNode(convertSchema(schema));
+	}
+
+	const normalized: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(schema)) {
+		normalized[key] = normalizeMixedSchemaNode(value);
+	}
+
+	return normalized;
+}
 /**
  * Convert JTD schema to JSON Schema.
  * If already JSON Schema, returns as-is.
  */
 export function jtdToJsonSchema(schema: unknown): unknown {
-	if (!isJTDSchema(schema)) {
-		return schema;
-	}
-	return convertSchema(schema);
+	return normalizeMixedSchemaNode(schema);
 }

package/src/tools/path-utils.ts

@@ -88,6 +88,40 @@ export function resolveToCwd(filePath: string, cwd: string): string {
 	return path.resolve(cwd, expanded);
 }
 
+const GLOB_PATH_CHARS = ["*", "?", "[", "{"] as const;
+
+export function hasGlobPathChars(filePath: string): boolean {
+	return GLOB_PATH_CHARS.some(char => filePath.includes(char));
+}
+
+export interface ParsedSearchPath {
+	basePath: string;
+	glob?: string;
+}
+
+/**
+ * Split a user path into a base path + glob pattern for tools that delegate to
+ * APIs accepting separate `path` and `glob` arguments.
+ */
+export function parseSearchPath(filePath: string): ParsedSearchPath {
+	const normalizedPath = filePath.replace(/\\/g, "/");
+	if (!hasGlobPathChars(normalizedPath)) {
+		return { basePath: filePath };
+	}
+
+	const segments = normalizedPath.split("/");
+	const firstGlobIndex = segments.findIndex(segment => hasGlobPathChars(segment));
+
+	if (firstGlobIndex <= 0) {
+		return { basePath: ".", glob: normalizedPath };
+	}
+
+	return {
+		basePath: segments.slice(0, firstGlobIndex).join("/"),
+		glob: segments.slice(firstGlobIndex).join("/"),
+	};
+}
+
 export function resolveReadPath(filePath: string, cwd: string): string {
 	const resolved = resolveToCwd(filePath, cwd);
 

package/src/tools/python.ts

@@ -21,6 +21,7 @@ import { resolveToCwd } from "./path-utils";
 import { formatTitle, replaceTabs, shortenPath, truncateToWidth, wrapBrackets } from "./render-utils";
 import { ToolAbortError, ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
+import { clampTimeout } from "./tool-timeouts";
 
 export const PYTHON_DEFAULT_PREVIEW_LINES = 10;
 
@@ -177,7 +178,7 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 
 		const { cells, timeout: rawTimeout = 30, cwd, reset } = params;
 		// Clamp to reasonable range: 1s - 600s (10 min)
-		const timeoutSec = Math.max(1, Math.min(600, rawTimeout));
+		const timeoutSec = clampTimeout("python", rawTimeout);
 		const timeoutMs = timeoutSec * 1000;
 		const timeoutSignal = AbortSignal.timeout(timeoutMs);
 		const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;

package/src/tools/renderers.ts

@@ -11,6 +11,8 @@ import { editToolRenderer } from "../patch";
 import { taskToolRenderer } from "../task/render";
 import { webSearchToolRenderer } from "../web/search/render";
 import { askToolRenderer } from "./ask";
+import { astFindToolRenderer } from "./ast-find";
+import { astReplaceToolRenderer } from "./ast-replace";
 import { bashToolRenderer } from "./bash";
 import { calculatorToolRenderer } from "./calculator";
 import { fetchToolRenderer } from "./fetch";
@@ -38,6 +40,8 @@ type ToolRenderer = {
 
 export const toolRenderers: Record<string, ToolRenderer> = {
 	ask: askToolRenderer as ToolRenderer,
+	ast_find: astFindToolRenderer as ToolRenderer,
+	ast_replace: astReplaceToolRenderer as ToolRenderer,
 	bash: bashToolRenderer as ToolRenderer,
 	python: pythonToolRenderer as ToolRenderer,
 	calc: calculatorToolRenderer as ToolRenderer,

package/src/tools/ssh.ts

@@ -19,6 +19,7 @@ import type { ToolSession } from ".";
 import { formatStyledTruncationWarning, type OutputMeta } from "./output-meta";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
+import { clampTimeout } from "./tool-timeouts";
 
 const sshSchema = Type.Object({
 	host: Type.String({ description: "Host name from managed SSH config or discovered ssh.json files" }),
@@ -155,7 +156,7 @@ export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
 		const remoteCommand = buildRemoteCommand(command, cwd, hostInfo);
 
 		// Clamp to reasonable range: 1s - 3600s (1 hour)
-		const timeoutSec = Math.max(1, Math.min(3600, rawTimeout));
+		const timeoutSec = clampTimeout("ssh", rawTimeout);
 		const timeoutMs = timeoutSec * 1000;
 
 		const tailBuffer = new TailBuffer(DEFAULT_MAX_BYTES);