@oh-my-pi/pi-coding-agent 13.10.0 → 13.11.0

package/src/tools/fetch.ts

@@ -7,6 +7,7 @@ import { ptree, truncate } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { parseHTML } from "linkedom";
 import { renderPromptTemplate } from "../config/prompt-templates";
+import type { Settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme, theme } from "../modes/theme/theme";
 import fetchDescription from "../prompts/tools/fetch.md" with { type: "text" };
@@ -15,6 +16,7 @@ import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { ensureTool } from "../utils/tools-manager";
+import { extractWithParallel, findParallelApiKey, getParallelExtractContent } from "../web/parallel";
 import { specialHandlers } from "../web/scrapers";
 import type { RenderResult } from "../web/scrapers/types";
 import { finalizeOutput, loadPage, MAX_OUTPUT_CHARS } from "../web/scrapers/types";
@@ -465,12 +467,13 @@ function parseFeedToMarkdown(content: string, maxItems = 10): string {
 }
 
 /**
- * Render HTML to markdown using jina, trafilatura, lynx (in order of preference)
+ * Render HTML to markdown using Parallel, jina, trafilatura, lynx (in order of preference)
  */
 async function renderHtmlToText(
 	url: string,
 	html: string,
 	timeout: number,
+	settings: Settings,
 	userSignal?: AbortSignal,
 ): Promise<{ content: string; ok: boolean; method: string }> {
 	const signal = ptree.combineSignals(userSignal, timeout * 1000);
@@ -482,6 +485,28 @@ async function renderHtmlToText(
 		signal,
 	};
 
+	// Try Parallel extract first when credentials are configured
+	if (settings.get("providers.parallelFetch") && (await findParallelApiKey())) {
+		try {
+			const parallelResult = await extractWithParallel([url], {
+				objective: "Extract the main content",
+				excerpts: true,
+				fullContent: false,
+				signal,
+			});
+			const firstDocument = parallelResult.results[0];
+			if (firstDocument) {
+				const content = getParallelExtractContent(firstDocument);
+				if (content.trim().length > 100 && !isLowQualityOutput(content)) {
+					return { content, ok: true, method: "parallel" };
+				}
+			}
+		} catch {
+			// Parallel extract failed, continue to next method
+			signal?.throwIfAborted();
+		}
+	}
+
 	// Try jina first (reader API)
 	try {
 		const jinaUrl = `https://r.jina.ai/${url}`;
@@ -608,7 +633,13 @@ async function handleSpecialUrls(
 /**
  * Main render function implementing the full pipeline
  */
-async function renderUrl(url: string, timeout: number, raw: boolean, signal?: AbortSignal): Promise<FetchRenderResult> {
+async function renderUrl(
+	url: string,
+	timeout: number,
+	raw: boolean,
+	settings: Settings,
+	signal?: AbortSignal,
+): Promise<FetchRenderResult> {
 	const notes: string[] = [];
 	const fetchedAt = new Date().toISOString();
 	if (signal?.aborted) {
@@ -714,7 +745,7 @@ async function renderUrl(url: string, timeout: number, raw: boolean, signal?: Ab
 				}
 
 				const resized = await resizeImage(
-					{ type: "image", data: binary.buffer.toBase64(), mimeType: imageMimeType },
+					{ type: "image", data: Buffer.from(binary.buffer).toBase64(), mimeType: imageMimeType },
 					{ maxBytes: MAX_INLINE_IMAGE_OUTPUT_BYTES },
 				);
 				const isDecodedImage =
@@ -952,7 +983,7 @@ async function renderUrl(url: string, timeout: number, raw: boolean, signal?: Ab
 		}
 
 		// 5E: Render HTML with lynx or html2text
-		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, signal);
+		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, settings, signal);
 		if (!htmlResult.ok) {
 			notes.push("html rendering failed (lynx/html2text unavailable)");
 			const output = finalizeOutput(rawContent);
@@ -1092,7 +1123,7 @@ export class FetchTool implements AgentTool<typeof fetchSchema, FetchToolDetails
 			throw new ToolAbortError();
 		}
 
-		const result = await renderUrl(url, effectiveTimeout, raw, signal);
+		const result = await renderUrl(url, effectiveTimeout, raw, this.session.settings, signal);
 		const truncation = truncateHead(result.content, {
 			maxBytes: DEFAULT_MAX_BYTES,
 			maxLines: FETCH_DEFAULT_MAX_LINES,

package/src/tools/find.ts

@@ -24,7 +24,7 @@ import {
 import type { ToolSession } from ".";
 import { applyListLimit } from "./list-limit";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
-import { resolveToCwd } from "./path-utils";
+import { parseFindPattern, resolveMultiFindPattern, resolveToCwd } from "./path-utils";
 import { formatCount, formatEmptyMessage, formatErrorMessage, PREVIEW_LIMITS } from "./render-utils";
 import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
@@ -40,56 +40,6 @@ export type FindToolInput = Static<typeof findSchema>;
 const DEFAULT_LIMIT = 1000;
 const GLOB_TIMEOUT_MS = 5000;
 
-/**
- * Parse a pattern to extract the base directory path and glob pattern.
- * Examples:
- *   "src/app/**\/*.tsx" → { basePath: "src/app", globPattern: "**\/*.tsx" }
- *   "src/app/*.tsx" → { basePath: "src/app", globPattern: "*.tsx" }
- *   "*.ts" → { basePath: ".", globPattern: "**\/*.ts" }
- *   "**\/*.json" → { basePath: ".", globPattern: "**\/*.json" }
- *   "/abs/path/**\/*.ts" → { basePath: "/abs/path", globPattern: "**\/*.ts" }
- */
-function parsePatternPath(pattern: string): { basePath: string; globPattern: string } {
-	// Find the first segment containing glob characters
-	const segments = pattern.split("/");
-	const globChars = ["*", "?", "[", "{"];
-
-	let firstGlobIndex = -1;
-	for (let i = 0; i < segments.length; i++) {
-		if (globChars.some(c => segments[i].includes(c))) {
-			firstGlobIndex = i;
-			break;
-		}
-	}
-
-	// No glob characters found - treat as literal path with implicit **/*
-	if (firstGlobIndex === -1) {
-		// Pattern is a directory path like "src/app" - search recursively in it
-		return { basePath: pattern, globPattern: "**/*" };
-	}
-
-	// Glob starts at first segment - no base path
-	if (firstGlobIndex === 0) {
-		// Simple pattern like "*.ts" needs **/ prefix for recursive search
-		const needsRecursive = !pattern.startsWith("**/");
-		return {
-			basePath: ".",
-			globPattern: needsRecursive ? `**/${pattern}` : pattern,
-		};
-	}
-
-	// Split at the glob boundary
-	const basePath = segments.slice(0, firstGlobIndex).join("/");
-	const globPattern = segments.slice(firstGlobIndex).join("/");
-
-	return { basePath, globPattern };
-}
-
-function hasGlobChars(pattern: string): boolean {
-	const globChars = ["*", "?", "[", "{"];
-	return globChars.some(char => pattern.includes(char));
-}
-
 export interface FindToolDetails {
 	truncation?: TruncationResult;
 	resultLimitReached?: number;
@@ -149,27 +99,26 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 		const { pattern, limit, hidden } = params;
 
 		return untilAborted(signal, async () => {
-			// Parse pattern to extract base directory and glob pattern
-			// e.g., "src/app/**/*.tsx" → basePath: "src/app", globPattern: "**/*.tsx"
-			// e.g., "*.ts" → basePath: ".", globPattern: "**/*.ts"
+			const formatScopePath = (targetPath: string): string => {
+				const relative = path.relative(this.session.cwd, targetPath).replace(/\\/g, "/");
+				return relative.length === 0 ? "." : relative;
+			};
 			const normalizedPattern = pattern.trim().replace(/\\/g, "/");
 			if (!normalizedPattern) {
 				throw new ToolError("Pattern must not be empty");
 			}
 
-			const hasGlob = hasGlobChars(normalizedPattern);
-			const { basePath, globPattern } = parsePatternPath(normalizedPattern);
-			const searchPath = resolveToCwd(basePath, this.session.cwd);
+			const multiPattern = await resolveMultiFindPattern(normalizedPattern, this.session.cwd);
+			const parsedPattern = multiPattern ? null : parseFindPattern(normalizedPattern);
+			const hasGlob = multiPattern ? true : (parsedPattern?.hasGlob ?? false);
+			const globPattern = multiPattern?.globPattern ?? parsedPattern?.globPattern ?? "**/*";
+			const searchPath = resolveToCwd(multiPattern?.basePath ?? parsedPattern?.basePath ?? ".", this.session.cwd);
+			const scopePath = multiPattern?.scopePath ?? formatScopePath(searchPath);
 
 			if (searchPath === "/") {
 				throw new ToolError("Searching from root directory '/' is not allowed");
 			}
 
-			const scopePath = (() => {
-				const relative = path.relative(this.session.cwd, searchPath).replace(/\\/g, "/");
-				return relative.length === 0 ? "." : relative;
-			})();
-
 			const rawLimit = limit ?? DEFAULT_LIMIT;
 			const effectiveLimit = Number.isFinite(rawLimit) ? Math.floor(rawLimit) : Number.NaN;
 			if (!Number.isFinite(effectiveLimit) || effectiveLimit <= 0) {
@@ -180,7 +129,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			// If custom operations provided with glob, use that instead of fd
 			if (this.#customOps?.glob) {
 				if (!(await this.#customOps.exists(searchPath))) {
-					throw new ToolError(`Path not found: ${searchPath}`);
+					throw new ToolError(`Path not found: ${scopePath}`);
 				}
 
 				if (!hasGlob && this.#customOps.stat) {
@@ -245,7 +194,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				searchStat = await fs.promises.stat(searchPath);
 			} catch (err) {
 				if (isEnoent(err)) {
-					throw new ToolError(`Path not found: ${searchPath}`);
+					throw new ToolError(`Path not found: ${scopePath}`);
 				}
 				throw err;
 			}

package/src/tools/grep.ts

@@ -16,7 +16,13 @@ import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, t
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
-import { combineSearchGlobs, hasGlobPathChars, parseSearchPath, resolveToCwd } from "./path-utils";
+import {
+	combineSearchGlobs,
+	hasGlobPathChars,
+	parseSearchPath,
+	resolveMultiSearchPath,
+	resolveToCwd,
+} from "./path-utils";
 import { formatCount, formatEmptyMessage, formatErrorMessage, PREVIEW_LIMITS } from "./render-utils";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
@@ -107,7 +113,12 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			const effectiveMultiline = multiline ?? patternHasNewline;
 
 			const useHashLines = resolveFileDisplayMode(this.session).hashLines;
+			const formatScopePath = (targetPath: string): string => {
+				const relative = path.relative(this.session.cwd, targetPath).replace(/\\/g, "/");
+				return relative.length === 0 ? "." : relative;
+			};
 			let searchPath: string;
+			let scopePath: string;
 			let globFilter = glob?.trim() || undefined;
 			const internalRouter = this.session.internalRouter;
 			if (searchDir?.trim()) {
@@ -121,27 +132,33 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 						throw new ToolError(`Cannot grep internal URL without a backing file: ${rawPath}`);
 					}
 					searchPath = resource.sourcePath;
+					scopePath = formatScopePath(searchPath);
 				} else {
-					const parsedPath = parseSearchPath(rawPath);
-					searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
-					if (parsedPath.glob) {
-						globFilter = combineSearchGlobs(parsedPath.glob, globFilter);
+					const multiSearchPath = await resolveMultiSearchPath(rawPath, this.session.cwd, globFilter);
+					if (multiSearchPath) {
+						searchPath = multiSearchPath.basePath;
+						globFilter = multiSearchPath.glob;
+						scopePath = multiSearchPath.scopePath;
+					} else {
+						const parsedPath = parseSearchPath(rawPath);
+						searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
+						if (parsedPath.glob) {
+							globFilter = combineSearchGlobs(parsedPath.glob, globFilter);
+						}
+						scopePath = formatScopePath(searchPath);
 					}
 				}
 			} else {
 				searchPath = resolveToCwd(".", this.session.cwd);
+				scopePath = ".";
 			}
-			const scopePath = (() => {
-				const relative = path.relative(this.session.cwd, searchPath).replace(/\\/g, "/");
-				return relative.length === 0 ? "." : relative;
-			})();
 
 			let isDirectory: boolean;
 			try {
 				const stat = await Bun.file(searchPath).stat();
 				isDirectory = stat.isDirectory();
 			} catch {
-				throw new ToolError(`Path not found: ${searchPath}`);
+				throw new ToolError(`Path not found: ${scopePath}`);
 			}
 
 			const effectiveOutputMode = "content";

package/src/tools/json-tree.ts

@@ -14,7 +14,7 @@ export const JSON_TREE_SCALAR_LEN_COLLAPSED = 60;
 export const JSON_TREE_SCALAR_LEN_EXPANDED = 2000;
 
 /** Keys injected by the harness that should not be displayed to users */
-const HIDDEN_ARG_KEYS = new Set([INTENT_FIELD]);
+const HIDDEN_ARG_KEYS = new Set([INTENT_FIELD, "__partialJson"]);
 
 /** Strip harness-internal keys from tool args for display */
 export function stripInternalArgs(args: Record<string, unknown>): Record<string, unknown> {

package/src/tools/output-meta.ts

@@ -12,6 +12,7 @@ import type {
 	AgentToolUpdateCallback,
 } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import { formatGroupedDiagnosticMessages } from "../lsp/utils";
 import type { Theme } from "../modes/theme/theme";
 import type { OutputSummary, TruncationResult } from "../session/streaming-output";
 import { formatBytes, wrapBrackets } from "./render-utils";
@@ -386,7 +387,7 @@ export function formatOutputNotice(meta: OutputMeta | undefined): string {
 	let diagnosticsNotice = "";
 	if (meta.diagnostics && meta.diagnostics.messages.length > 0) {
 		const d = meta.diagnostics;
-		diagnosticsNotice = `\n\nLSP Diagnostics (${d.summary}):\n  ${d.messages.join("\n  ")}`;
+		diagnosticsNotice = `\n\nLSP Diagnostics (${d.summary}):\n${formatGroupedDiagnosticMessages(d.messages)}`;
 	}
 
 	const notice = parts.length ? `\n\n[${parts.join(". ")}]` : "";