@oh-my-pi/pi-coding-agent 15.10.4 → 15.10.6

package/src/utils/block-context.ts

@@ -0,0 +1,312 @@
+import { enclosingBlockBoundaries } from "@oh-my-pi/pi-natives";
+import { logger } from "@oh-my-pi/pi-utils";
+
+const OPEN_TO_CLOSE: Record<string, string> = {
+	"(": ")",
+	"[": "]",
+	"{": "}",
+};
+
+const CLOSE_TO_OPEN: Record<string, string> = {
+	")": "(",
+	"]": "[",
+	"}": "{",
+};
+
+export interface LineSpan {
+	startLine: number;
+	endLine: number;
+}
+
+/** Where the source came from, so tree-sitter can pick a grammar. */
+export interface BlockContextSource {
+	path?: string;
+	lang?: string;
+}
+
+export type LineEntry = { kind: "line"; lineNumber: number; text: string; context: boolean } | { kind: "ellipsis" };
+
+interface StackEntry {
+	opener: string;
+	lineNumber: number;
+	text: string;
+	visible: boolean;
+}
+
+type ScannerMode = "code" | "single" | "double" | "template" | "blockComment";
+
+function normalizeLineSpans(spans: readonly LineSpan[], totalLines: number): LineSpan[] {
+	if (totalLines <= 0) return [];
+	const normalized: LineSpan[] = [];
+	for (const span of spans) {
+		const startLine = Math.max(1, Math.trunc(span.startLine));
+		const endLine = Math.min(totalLines, Math.trunc(span.endLine));
+		if (endLine < startLine) continue;
+		normalized.push({ startLine, endLine });
+	}
+	if (normalized.length <= 1) return normalized;
+	normalized.sort((left, right) => left.startLine - right.startLine || left.endLine - right.endLine);
+	const merged: LineSpan[] = [];
+	for (const span of normalized) {
+		const previous = merged[merged.length - 1];
+		if (previous && span.startLine <= previous.endLine + 1) {
+			previous.endLine = Math.max(previous.endLine, span.endLine);
+			continue;
+		}
+		merged.push({ ...span });
+	}
+	return merged;
+}
+
+function visibleLineNumbers(spans: readonly LineSpan[]): Set<number> {
+	const visible = new Set<number>();
+	for (const span of spans) {
+		for (let line = span.startLine; line <= span.endLine; line++) {
+			visible.add(line);
+		}
+	}
+	return visible;
+}
+
+function hasEveryLineVisible(visible: ReadonlySet<number>, totalLines: number): boolean {
+	return totalLines > 0 && visible.size >= totalLines;
+}
+
+/** Collapse a set of visible line numbers into sorted, merged inclusive spans. */
+function visibleSetToSpans(visible: ReadonlySet<number>): LineSpan[] {
+	const sorted = [...visible].sort((left, right) => left - right);
+	const spans: LineSpan[] = [];
+	for (const line of sorted) {
+		const previous = spans[spans.length - 1];
+		if (previous && line <= previous.endLine + 1) {
+			previous.endLine = line;
+			continue;
+		}
+		spans.push({ startLine: line, endLine: line });
+	}
+	return spans;
+}
+
+/**
+ * Tree-sitter-backed block boundaries. For each multi-line named node whose
+ * span crosses the visible window, the native side returns the boundary line
+ * outside that window (closer when the opener is shown, opener when the closer
+ * is shown). Returns `null` when the language is unrecognized or the source has
+ * a syntax error so the caller can fall back to a lexical bracket scan.
+ */
+function nativeBlockContext(
+	fullLines: readonly string[],
+	visible: ReadonlySet<number>,
+	source: BlockContextSource,
+): Map<number, string> | null {
+	if (!source.path && !source.lang) return null;
+	const ranges = visibleSetToSpans(visible);
+	if (ranges.length === 0) return new Map();
+	let boundaries: number[] | null;
+	try {
+		boundaries = enclosingBlockBoundaries({
+			code: fullLines.join("\n"),
+			path: source.path,
+			lang: source.lang,
+			ranges,
+		});
+	} catch (error) {
+		logger.debug("enclosingBlockBoundaries failed; using lexical bracket fallback", { error });
+		return null;
+	}
+	if (boundaries === null) return null;
+	const context = new Map<number, string>();
+	for (const lineNumber of boundaries) {
+		if (visible.has(lineNumber)) continue;
+		context.set(lineNumber, fullLines[lineNumber - 1] ?? "");
+	}
+	return context;
+}
+
+function findMatchingStackIndex(stack: readonly StackEntry[], opener: string): number {
+	for (let index = stack.length - 1; index >= 0; index--) {
+		if (stack[index].opener === opener) return index;
+	}
+	return -1;
+}
+
+function isHashCommentStart(line: string, index: number): boolean {
+	if (line[index] !== "#") return false;
+	for (let i = 0; i < index; i++) {
+		const ch = line[i];
+		if (ch !== " " && ch !== "\t") return false;
+	}
+	return true;
+}
+
+/**
+ * Lexical bracket-matching fallback for sources tree-sitter can't parse
+ * (unknown extensions, syntax errors). Pairs `()[]{}` while skipping strings
+ * and line/block comments, and reports the matching line when one endpoint is
+ * visible and the other is not.
+ */
+function lexicalBracketContext(fullLines: readonly string[], visible: ReadonlySet<number>): Map<number, string> {
+	const context = new Map<number, string>();
+	const stack: StackEntry[] = [];
+	let mode: ScannerMode = "code";
+	let escaped = false;
+
+	for (let lineIndex = 0; lineIndex < fullLines.length; lineIndex++) {
+		const lineNumber = lineIndex + 1;
+		const line = fullLines[lineIndex] ?? "";
+		const lineVisible = visible.has(lineNumber);
+		let index = 0;
+		while (index < line.length) {
+			const ch = line[index];
+			const next = index + 1 < line.length ? line[index + 1] : "";
+
+			if (mode === "blockComment") {
+				if (ch === "*" && next === "/") {
+					mode = "code";
+					index += 2;
+					continue;
+				}
+				index++;
+				continue;
+			}
+
+			if (mode === "single" || mode === "double" || mode === "template") {
+				if (escaped) {
+					escaped = false;
+					index++;
+					continue;
+				}
+				if (ch === "\\") {
+					escaped = true;
+					index++;
+					continue;
+				}
+				if (
+					(mode === "single" && ch === "'") ||
+					(mode === "double" && ch === '"') ||
+					(mode === "template" && ch === "`")
+				) {
+					mode = "code";
+				}
+				index++;
+				continue;
+			}
+
+			if (ch === "/" && next === "/") break;
+			if (ch === "/" && next === "*") {
+				mode = "blockComment";
+				index += 2;
+				continue;
+			}
+			if (isHashCommentStart(line, index)) break;
+			if (ch === "'") {
+				mode = "single";
+				escaped = false;
+				index++;
+				continue;
+			}
+			if (ch === '"') {
+				mode = "double";
+				escaped = false;
+				index++;
+				continue;
+			}
+			if (ch === "`") {
+				mode = "template";
+				escaped = false;
+				index++;
+				continue;
+			}
+
+			if (OPEN_TO_CLOSE[ch]) {
+				stack.push({ opener: ch, lineNumber, text: line, visible: lineVisible });
+				index++;
+				continue;
+			}
+
+			const opener = CLOSE_TO_OPEN[ch];
+			if (opener) {
+				const matchIndex = findMatchingStackIndex(stack, opener);
+				if (matchIndex !== -1) {
+					const [matched] = stack.splice(matchIndex);
+					if (matched) {
+						if (lineVisible && !matched.visible) context.set(matched.lineNumber, matched.text);
+						if (matched.visible && !lineVisible) context.set(lineNumber, line);
+					}
+				}
+			}
+
+			index++;
+		}
+
+		if (mode === "single" || mode === "double") {
+			mode = "code";
+			escaped = false;
+		}
+	}
+
+	for (const lineNumber of visible) context.delete(lineNumber);
+	return context;
+}
+
+/**
+ * Resolve the off-window boundary lines for a visible window: tree-sitter
+ * syntactic spans first (covers brace and indentation languages), falling back
+ * to a lexical bracket scan when the grammar is unavailable. Returns a map of
+ * `lineNumber → source text` for the lines to surface, never including a line
+ * already visible.
+ */
+export function findBlockContextLines(
+	fullLines: readonly string[],
+	visibleInput: ReadonlySet<number> | readonly number[],
+	source: BlockContextSource = {},
+): Map<number, string> {
+	const visible = visibleInput instanceof Set ? visibleInput : new Set(visibleInput);
+	if (visible.size === 0 || hasEveryLineVisible(visible, fullLines.length)) return new Map();
+	return nativeBlockContext(fullLines, visible, source) ?? lexicalBracketContext(fullLines, visible);
+}
+
+/**
+ * Build display entries for `visibleSpans` plus any off-window block-boundary
+ * lines, in source order, with `{ kind: "ellipsis" }` markers inserted across
+ * non-contiguous gaps. `options.lineText` lets callers substitute display text
+ * (e.g. column-truncated lines) for a given line number.
+ */
+export function buildLineEntriesWithBlockContext(
+	fullLines: readonly string[],
+	visibleSpans: readonly LineSpan[],
+	source: BlockContextSource = {},
+	options: {
+		lineText?: (lineNumber: number, sourceText: string, context: boolean) => string;
+	} = {},
+): LineEntry[] {
+	const spans = normalizeLineSpans(visibleSpans, fullLines.length);
+	const visible = visibleLineNumbers(spans);
+	const context = findBlockContextLines(fullLines, visible, source);
+	const allLines = new Set<number>(visible);
+	for (const lineNumber of context.keys()) allLines.add(lineNumber);
+
+	const sorted = [...allLines].sort((left, right) => left - right);
+	const entries: LineEntry[] = [];
+	let previousLine: number | undefined;
+	for (const lineNumber of sorted) {
+		if (previousLine !== undefined && lineNumber > previousLine + 1) {
+			entries.push({ kind: "ellipsis" });
+		}
+		const sourceText = fullLines[lineNumber - 1] ?? "";
+		const isContext = context.has(lineNumber);
+		entries.push({
+			kind: "line",
+			lineNumber,
+			text: options.lineText?.(lineNumber, sourceText, isContext) ?? sourceText,
+			context: isContext,
+		});
+		previousLine = lineNumber;
+	}
+
+	return entries;
+}
+
+export function lineEntriesToPlainText(entries: readonly LineEntry[], ellipsis = "…"): string {
+	return entries.map(entry => (entry.kind === "ellipsis" ? ellipsis : entry.text)).join("\n");
+}

package/src/utils/git.ts

@@ -45,6 +45,10 @@ export interface StageHunksOptions {
 	readonly rawDiff?: string;
 	readonly signal?: AbortSignal;
 }
+export interface HunkSelectionValidationError {
+	readonly path: string;
+	readonly message: string;
+}
 
 export interface DiffOptions {
 	readonly allowFailure?: boolean;
@@ -678,6 +682,43 @@ function selectHunks(file: FileHunks, selector: HunkSelection["hunks"]): FileHun
 	return file.hunks;
 }
 
+export function createHunkSelectionValidator(
+	rawDiff: string,
+): (selections: readonly HunkSelection[]) => HunkSelectionValidationError[] {
+	const fileDiffMap = new Map(parseFileDiffs(rawDiff).map(entry => [entry.filename, entry]));
+	return selections => validateHunkSelectionsFromMap(fileDiffMap, selections);
+}
+
+function validateHunkSelectionsFromMap(
+	fileDiffMap: ReadonlyMap<string, FileDiff>,
+	selections: readonly HunkSelection[],
+): HunkSelectionValidationError[] {
+	const errors: HunkSelectionValidationError[] = [];
+
+	for (const selection of selections) {
+		const fileDiff = fileDiffMap.get(selection.path);
+		if (!fileDiff) continue;
+		if (selection.hunks.type === "all") continue;
+		if (fileDiff.isBinary) {
+			errors.push({ path: selection.path, message: `Cannot select hunks for binary file ${selection.path}` });
+			continue;
+		}
+		const selected = selectHunks(parseFileHunks(fileDiff), selection.hunks);
+		if (selected.length === 0) {
+			errors.push({ path: selection.path, message: `No hunks selected for ${selection.path}` });
+		}
+	}
+
+	return errors;
+}
+
+export function validateHunkSelections(
+	rawDiff: string,
+	selections: readonly HunkSelection[],
+): HunkSelectionValidationError[] {
+	return createHunkSelectionValidator(rawDiff)(selections);
+}
+
 function parseStatusPorcelain(text: string): GitStatusSummary {
 	let staged = 0;
 	let unstaged = 0;

package/src/utils/image-loading.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { formatBytes, readImageMetadata, SUPPORTED_IMAGE_MIME_TYPES } from "@oh-my-pi/pi-utils";
 import { resolveReadPath } from "../tools/path-utils";
-import { formatDimensionNote, resizeImage } from "./image-resize";
+import { formatDimensionNote, type ImageResizeOptions, resizeImage } from "./image-resize";
 
 export const MAX_IMAGE_INPUT_BYTES = 20 * 1024 * 1024;
 export const SUPPORTED_INPUT_IMAGE_MIME_TYPES = SUPPORTED_IMAGE_MIME_TYPES;
@@ -50,6 +50,36 @@ export async function ensureSupportedImageInput(image: ImageContent): Promise<Im
 	}
 }
 
+export interface NormalizeModelContextImagesOptions {
+	resize?: ImageResizeOptions;
+}
+
+/**
+ * Normalize image blocks before they enter agent/model context. This keeps
+ * provider request construction from having to resize an unbounded batch of
+ * large images on the streaming hot path. Images are processed sequentially on
+ * purpose: `resizeImage` may fan out multiple encoders for one image, so the
+ * outer image batch must stay bounded.
+ */
+export async function normalizeModelContextImages(
+	images: ImageContent[] | undefined,
+	options?: NormalizeModelContextImagesOptions,
+): Promise<ImageContent[] | undefined> {
+	if (!images || images.length === 0) return undefined;
+	const normalized: ImageContent[] = [];
+	for (const image of images) {
+		try {
+			const resized = await resizeImage(image, options?.resize);
+			normalized.push({ type: "image", data: resized.data, mimeType: resized.mimeType });
+		} catch {
+			// Preserve existing caller behavior for decode/resize failures: keep the
+			// user's image block rather than dropping it from the turn.
+			normalized.push(image);
+		}
+	}
+	return normalized;
+}
+
 export async function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null> {
 	const maxBytes = options.maxBytes ?? MAX_IMAGE_INPUT_BYTES;
 	const resolvedPath = options.resolvedPath ?? resolveReadPath(options.path, options.cwd);

package/src/web/search/providers/codex.ts

@@ -8,7 +8,7 @@
  */
 import * as os from "node:os";
 import { type AuthStorage, getBundledModels } from "@oh-my-pi/pi-ai";
-import { decodeJwt } from "@oh-my-pi/pi-ai/utils/oauth/openai-codex";
+import { decodeJwt } from "@oh-my-pi/pi-ai/oauth/openai-codex";
 import { $env, readSseJson } from "@oh-my-pi/pi-utils";
 import packageJson from "../../../../package.json" with { type: "json" };
 import type { SearchResponse, SearchSource } from "../../../web/search/types";

package/src/web/search/render.ts

@@ -117,13 +117,21 @@ export function renderSearchResult(
 		: searchQueries[0]
 			? truncateToWidth(searchQueries[0], 80)
 			: undefined;
+	const success = sourceCount > 0;
 	const header = renderStatusLine(
-		{
-			icon: sourceCount > 0 ? "success" : "warning",
-			title: "Web Search",
-			description: providerLabel,
-			meta: [formatCount("source", sourceCount)],
-		},
+		success
+			? {
+					iconOverride: theme.styledSymbol("tool.webSearch", "accent"),
+					title: "Web Search",
+					description: providerLabel,
+					meta: [formatCount("source", sourceCount)],
+				}
+			: {
+					icon: "warning",
+					title: "Web Search",
+					description: providerLabel,
+					meta: [formatCount("source", sourceCount)],
+				},
 		theme,
 	);
 

package/dist/types/exa/factory.d.ts

@@ -1,13 +0,0 @@
-/**
- * Shared factory for creating Exa tools with consistent error handling and response formatting.
- */
-import type { TSchema } from "@oh-my-pi/pi-ai";
-import type { CustomTool } from "../extensibility/custom-tools/types";
-import type { ExaRenderDetails } from "./types";
-/** Creates an Exa tool with standardized API key handling, error wrapping, and optional search response formatting. */
-export declare function createExaTool(name: string, label: string, description: string, parameters: TSchema, mcpToolName: string, options?: {
-    /** When true, checks isSearchResponse and formats with formatSearchResults. Default: true */
-    formatResponse?: boolean;
-    /** Transform params before passing to callExaTool */
-    transformParams?: (params: Record<string, unknown>) => Record<string, unknown>;
-}): CustomTool<TSchema, ExaRenderDetails>;

package/dist/types/exa/render.d.ts

@@ -1,19 +0,0 @@
-/**
- * Exa TUI Rendering
- *
- * Tree-based rendering with collapsed/expanded states for Exa search results.
- */
-import type { Component } from "@oh-my-pi/pi-tui";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import type { Theme } from "../modes/theme/theme";
-import type { ExaRenderDetails } from "./types";
-/** Render Exa result with tree-based layout */
-export declare function renderExaResult(result: {
-    content: Array<{
-        type: string;
-        text?: string;
-    }>;
-    details?: ExaRenderDetails;
-}, options: RenderResultOptions, uiTheme: Theme): Component;
-/** Render Exa call (query/args preview) */
-export declare function renderExaCall(args: Record<string, unknown>, toolName: string, uiTheme: Theme): Component;

package/dist/types/exa/researcher.d.ts

@@ -1,9 +0,0 @@
-/**
- * Exa Researcher Tools
- *
- * Async research tasks with polling for completion.
- */
-import type { TSchema } from "@oh-my-pi/pi-ai";
-import type { CustomTool } from "../extensibility/custom-tools/types";
-import type { ExaRenderDetails } from "./types";
-export declare const researcherTools: CustomTool<TSchema, ExaRenderDetails>[];

package/dist/types/exa/search.d.ts

@@ -1,9 +0,0 @@
-/**
- * Exa Search Tools
- *
- * Basic neural/keyword search, deep research, code search, and URL crawling.
- */
-import type { TSchema } from "@oh-my-pi/pi-ai";
-import type { CustomTool } from "../extensibility/custom-tools/types";
-import type { ExaRenderDetails } from "./types";
-export declare const searchTools: CustomTool<TSchema, ExaRenderDetails>[];

package/dist/types/exa/websets.d.ts

@@ -1,9 +0,0 @@
-/**
- * Exa Websets Tools
- *
- * CRUD operations for websets, items, searches, enrichments, and monitoring.
- */
-import type { TSchema } from "@oh-my-pi/pi-ai";
-import type { CustomTool } from "../extensibility/custom-tools/types";
-import type { ExaRenderDetails } from "./types";
-export declare const websetsTools: CustomTool<TSchema, ExaRenderDetails>[];

package/src/exa/factory.ts

@@ -1,60 +0,0 @@
-/**
- * Shared factory for creating Exa tools with consistent error handling and response formatting.
- */
-import type { TSchema } from "@oh-my-pi/pi-ai";
-import type { CustomTool } from "../extensibility/custom-tools/types";
-import { callExaTool, findApiKey, formatGenericResponse, formatSearchResults, isSearchResponse } from "./mcp-client";
-import type { ExaRenderDetails } from "./types";
-
-/** Creates an Exa tool with standardized API key handling, error wrapping, and optional search response formatting. */
-export function createExaTool(
-	name: string,
-	label: string,
-	description: string,
-	parameters: TSchema,
-	mcpToolName: string,
-	options?: {
-		/** When true, checks isSearchResponse and formats with formatSearchResults. Default: true */
-		formatResponse?: boolean;
-		/** Transform params before passing to callExaTool */
-		transformParams?: (params: Record<string, unknown>) => Record<string, unknown>;
-	},
-): CustomTool<TSchema, ExaRenderDetails> {
-	const formatResponse = options?.formatResponse ?? true;
-	const transformParams = options?.transformParams;
-
-	return {
-		name,
-		label,
-		description,
-		parameters,
-		async execute(_toolCallId, params, _onUpdate, _ctx, _signal) {
-			try {
-				const apiKey = findApiKey();
-				// Exa MCP endpoint is publicly accessible; API key is optional
-				const rawArgs = params as Record<string, unknown>;
-				const args = transformParams ? transformParams(rawArgs) : rawArgs;
-				const response = await callExaTool(mcpToolName, args, apiKey);
-
-				if (formatResponse && isSearchResponse(response)) {
-					const formatted = formatSearchResults(response);
-					return {
-						content: [{ type: "text" as const, text: formatted }],
-						details: { response, toolName: name },
-					};
-				}
-
-				return {
-					content: [{ type: "text" as const, text: formatGenericResponse(response) }],
-					details: { raw: response, toolName: name },
-				};
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				return {
-					content: [{ type: "text" as const, text: `Error: ${message}` }],
-					details: { error: message, toolName: name },
-				};
-			}
-		},
-	};
-}