@oh-my-pi/pi-coding-agent 17.1.1 → 17.1.2

package/src/tools/eval-format/ruby.ts

@@ -0,0 +1,380 @@
+const INDENT = "    ";
+
+const OPENING_KEYWORDS: Record<string, true> = {
+	begin: true,
+	case: true,
+	class: true,
+	def: true,
+	for: true,
+	if: true,
+	module: true,
+	unless: true,
+	until: true,
+	while: true,
+};
+
+const BRANCH_KEYWORDS: Record<string, true> = {
+	else: true,
+	elsif: true,
+	ensure: true,
+	rescue: true,
+	when: true,
+};
+
+const PAIRED_DELIMITERS: Record<string, string> = {
+	"(": ")",
+	"[": "]",
+	"{": "}",
+	"<": ">",
+};
+
+type Quote = "'" | '"' | "`";
+
+interface QuotedContext {
+	kind: "quoted";
+	quote: Quote;
+	interpolated: boolean;
+	escaped: boolean;
+}
+
+interface PercentContext {
+	kind: "percent";
+	open: string;
+	close: string;
+	depth: number;
+	interpolated: boolean;
+	escaped: boolean;
+}
+
+interface InterpolationContext {
+	kind: "interpolation";
+	braceDepth: number;
+}
+
+interface CommentContext {
+	kind: "comment";
+}
+
+type LexicalContext = QuotedContext | PercentContext | InterpolationContext | CommentContext;
+
+interface PercentLiteralStart {
+	end: number;
+	open: string;
+	close: string;
+	interpolated: boolean;
+}
+
+function isHorizontalWhitespace(character: string): boolean {
+	return character === " " || character === "\t" || character === "\f" || character === "\v";
+}
+
+function isIdentifierStart(character: string | undefined): boolean {
+	if (character === undefined) return false;
+	const code = character.charCodeAt(0);
+	return (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || character === "_";
+}
+
+function isIdentifierPart(character: string | undefined): boolean {
+	if (character === undefined) return false;
+	const code = character.charCodeAt(0);
+	return isIdentifierStart(character) || (code >= 48 && code <= 57);
+}
+
+function findPercentLiteral(source: string, start: number): PercentLiteralStart | undefined {
+	let delimiterIndex = start + 1;
+	let type = "";
+	const candidateType = source[delimiterIndex];
+	if (candidateType !== undefined && "qQwWiIxrs".includes(candidateType)) {
+		type = candidateType;
+		delimiterIndex++;
+	}
+
+	const open = source[delimiterIndex];
+	if (open === undefined || isIdentifierPart(open) || /\s/.test(open)) return undefined;
+	return {
+		end: delimiterIndex + 1,
+		open,
+		close: PAIRED_DELIMITERS[open] ?? open,
+		interpolated: type === "" || type === "Q" || type === "W" || type === "I" || type === "x" || type === "r",
+	};
+}
+
+function formatRubyPrefix(source: string): string {
+	const output: string[] = [];
+	const contexts: LexicalContext[] = [];
+	const delimiters: string[] = [];
+	let lineParts: string[] = [];
+	let lineHasVisibleText = false;
+	let preserveLeadingWhitespace = false;
+	let pendingSemicolonBreak = false;
+	let blockDepth = 0;
+	let hasSignificantToken = false;
+	let leadingWord: string | null = null;
+	let previousToken = "";
+	let hasDo = false;
+	let endCount = 0;
+	let endlessDefinition = false;
+
+	const append = (text: string): void => {
+		lineParts.push(text);
+		if (lineHasVisibleText) return;
+		for (let index = 0; index < text.length; index++) {
+			if (!isHorizontalWhitespace(text[index])) {
+				lineHasVisibleText = true;
+				return;
+			}
+		}
+	};
+
+	const observeOtherToken = (value: string): void => {
+		if (!hasSignificantToken) {
+			hasSignificantToken = true;
+			leadingWord = null;
+		}
+		previousToken = value;
+	};
+
+	const resetLine = (): void => {
+		lineParts = [];
+		lineHasVisibleText = false;
+		preserveLeadingWhitespace = contexts.length > 0 || delimiters.length > 0;
+		hasSignificantToken = false;
+		leadingWord = null;
+		previousToken = "";
+		hasDo = false;
+		endCount = 0;
+		endlessDefinition = false;
+	};
+
+	const flushLine = (ending: string): void => {
+		const raw = lineParts.join("");
+		const leadingEnd = leadingWord === "end";
+		const branch = leadingWord !== null && BRANCH_KEYWORDS[leadingWord] === true;
+		const opens =
+			!endlessDefinition &&
+			((leadingWord !== null && OPENING_KEYWORDS[leadingWord] === true) || (!leadingEnd && !branch && hasDo));
+		const indentation = leadingEnd || branch ? Math.max(0, blockDepth - 1) : blockDepth;
+		blockDepth = Math.max(0, blockDepth + (opens ? 1 : 0) - endCount);
+
+		if (preserveLeadingWhitespace) {
+			output.push(raw, ending);
+			return;
+		}
+
+		let contentStart = 0;
+		while (contentStart < raw.length && isHorizontalWhitespace(raw[contentStart])) contentStart++;
+		const content = raw.slice(contentStart);
+		output.push(content.length === 0 ? "" : INDENT.repeat(indentation) + content, ending);
+	};
+
+	for (let index = 0; index < source.length; ) {
+		const character = source[index];
+		if (character === "\n" || character === "\r") {
+			const ending = character === "\r" && source[index + 1] === "\n" ? "\r\n" : character;
+			const top = contexts[contexts.length - 1];
+			if (top?.kind === "comment") {
+				contexts.pop();
+			} else if (top?.kind === "quoted" || top?.kind === "percent") {
+				top.escaped = false;
+			}
+
+			if (pendingSemicolonBreak && !lineHasVisibleText) {
+				pendingSemicolonBreak = false;
+				resetLine();
+			} else {
+				flushLine(ending);
+				pendingSemicolonBreak = false;
+				resetLine();
+			}
+			index += ending.length;
+			continue;
+		}
+
+		const top = contexts[contexts.length - 1];
+		if (top?.kind === "comment") {
+			append(character);
+			index++;
+			continue;
+		}
+
+		if (top?.kind === "quoted") {
+			append(character);
+			if (top.escaped) {
+				top.escaped = false;
+				index++;
+				continue;
+			}
+			if (character === "\\") {
+				top.escaped = true;
+				index++;
+				continue;
+			}
+			if (top.interpolated && character === "#" && source[index + 1] === "{") {
+				append("{");
+				contexts.push({ kind: "interpolation", braceDepth: 1 });
+				index += 2;
+				continue;
+			}
+			if (character === top.quote) contexts.pop();
+			index++;
+			continue;
+		}
+
+		if (top?.kind === "percent") {
+			append(character);
+			if (top.escaped) {
+				top.escaped = false;
+				index++;
+				continue;
+			}
+			if (character === "\\") {
+				top.escaped = true;
+				index++;
+				continue;
+			}
+			if (top.interpolated && character === "#" && source[index + 1] === "{") {
+				append("{");
+				contexts.push({ kind: "interpolation", braceDepth: 1 });
+				index += 2;
+				continue;
+			}
+			if (top.open !== top.close && character === top.open) {
+				top.depth++;
+			} else if (character === top.close) {
+				top.depth--;
+				if (top.depth === 0) contexts.pop();
+			}
+			index++;
+			continue;
+		}
+
+		const interpolation = top?.kind === "interpolation" ? top : undefined;
+		const inRootCode = interpolation === undefined;
+		if (interpolation !== undefined && character === "}") {
+			append(character);
+			interpolation.braceDepth--;
+			if (interpolation.braceDepth === 0) contexts.pop();
+			index++;
+			continue;
+		}
+
+		if (character === "#") {
+			append(character);
+			contexts.push({ kind: "comment" });
+			index++;
+			continue;
+		}
+
+		if (character === "'" || character === '"' || character === "`") {
+			if (inRootCode && delimiters.length === 0) observeOtherToken("literal");
+			append(character);
+			contexts.push({ kind: "quoted", quote: character, interpolated: character !== "'", escaped: false });
+			index++;
+			continue;
+		}
+
+		if (character === "%") {
+			const literal = findPercentLiteral(source, index);
+			if (literal !== undefined) {
+				if (inRootCode && delimiters.length === 0) observeOtherToken("literal");
+				append(source.slice(index, literal.end));
+				contexts.push({
+					kind: "percent",
+					open: literal.open,
+					close: literal.close,
+					depth: 1,
+					interpolated: literal.interpolated,
+					escaped: false,
+				});
+				index = literal.end;
+				continue;
+			}
+		}
+
+		if (isIdentifierStart(character)) {
+			let end = index + 1;
+			while (isIdentifierPart(source[end])) end++;
+			if (source[end] === "?" || source[end] === "!") end++;
+			const word = source.slice(index, end);
+			append(word);
+
+			if (inRootCode && delimiters.length === 0) {
+				const blockedByPrefix =
+					previousToken === ":" || previousToken === "." || previousToken === "@" || previousToken === "$";
+				const label = source[end] === ":" && source[end + 1] !== ":";
+				const eligible = !blockedByPrefix && !label;
+				if (!hasSignificantToken) {
+					hasSignificantToken = true;
+					leadingWord = eligible ? word : null;
+				}
+				if (eligible && word === "do") hasDo = true;
+				if (eligible && word === "end") endCount++;
+				previousToken = "word";
+			}
+			index = end;
+			continue;
+		}
+
+		if (interpolation !== undefined && character === "{") {
+			append(character);
+			interpolation.braceDepth++;
+			index++;
+			continue;
+		}
+
+		if (inRootCode && (character === "(" || character === "[" || character === "{")) {
+			if (delimiters.length === 0) observeOtherToken(character);
+			append(character);
+			delimiters.push(character);
+			index++;
+			continue;
+		}
+
+		if (inRootCode && (character === ")" || character === "]" || character === "}")) {
+			append(character);
+			const open = delimiters[delimiters.length - 1];
+			if (open !== undefined && PAIRED_DELIMITERS[open] === character) delimiters.pop();
+			if (delimiters.length === 0) observeOtherToken(character);
+			index++;
+			continue;
+		}
+
+		if (character === ";") {
+			append(character);
+			if (inRootCode && delimiters.length === 0) {
+				observeOtherToken(character);
+				flushLine("\n");
+				pendingSemicolonBreak = true;
+				resetLine();
+			}
+			index++;
+			continue;
+		}
+
+		append(character);
+		if (inRootCode && delimiters.length === 0 && !isHorizontalWhitespace(character)) {
+			if (
+				character === "=" &&
+				leadingWord === "def" &&
+				/\s/.test(source[index - 1] ?? "") &&
+				source[index + 1] !== "="
+			) {
+				endlessDefinition = true;
+			}
+			observeOtherToken(character);
+		}
+		index++;
+	}
+
+	if (lineParts.length > 0 && !(pendingSemicolonBreak && !lineHasVisibleText)) flushLine("");
+	return output.join("");
+}
+
+/** Formats an arbitrary Ruby source prefix for display without requiring valid syntax. */
+export function formatRubyForDisplay(source: string): string {
+	try {
+		return formatRubyPrefix(source);
+	} catch {
+		return source;
+	}
+}

package/src/tools/eval-render.ts

@@ -19,6 +19,7 @@ import { formatContextUsage } from "../modes/components/status-line/context-thre
 import { truncateToVisualLines } from "../modes/components/visual-truncate";
 import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
 import { markFramedBlockComponent, outputBlockContentWidth, renderCodeCell } from "../tui";
+import { formatEvalCodeForDisplay } from "./eval-format";
 import {
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
 	JSON_TREE_MAX_DEPTH_EXPANDED,
@@ -89,10 +90,11 @@ function getRenderCells(args: EvalRenderArgs | undefined): EvalRenderCell[] {
 	const out: EvalRenderCell[] = [];
 	for (const cell of raw) {
 		if (!cell || typeof cell !== "object") continue;
+		const language = normalizeRenderLanguage(typeof cell.language === "string" ? cell.language : undefined);
 		const code = typeof cell.code === "string" ? cell.code : "";
 		out.push({
-			language: normalizeRenderLanguage(typeof cell.language === "string" ? cell.language : undefined),
-			code,
+			language,
+			code: formatEvalCodeForDisplay(code, language),
 			title: typeof cell.title === "string" ? cell.title : undefined,
 		});
 	}
@@ -587,6 +589,10 @@ export const evalToolRenderer = {
 
 		const cellResults = details?.cells;
 		if (cellResults && cellResults.length > 0) {
+			const displayCells = cellResults.map(cell => {
+				const language = cell.language ?? details?.language ?? "python";
+				return { cell, code: formatEvalCodeForDisplay(cell.code, language), language };
+			});
 			let cached: { key: string; width: number; result: string[] } | undefined;
 
 			return markFramedBlockComponent({
@@ -602,8 +608,8 @@ export const evalToolRenderer = {
 					}
 
 					const lines: string[] = [];
-					for (let i = 0; i < cellResults.length; i++) {
-						const cell = cellResults[i];
+					for (let i = 0; i < displayCells.length; i++) {
+						const { cell, code, language } = displayCells[i];
 						const allEvents = cell.statusEvents ?? [];
 						const agentEvents = allEvents.filter(e => e.op === "agent");
 						const otherEvents = agentEvents.length > 0 ? allEvents.filter(e => e.op !== "agent") : allEvents;
@@ -623,8 +629,8 @@ export const evalToolRenderer = {
 						}
 						const cellLines = renderCodeCell(
 							{
-								code: cell.code,
-								language: languageForHighlighter(cell.language ?? details?.language),
+								code,
+								language: languageForHighlighter(language),
 								showLanguage: true,
 								index: i,
 								total: cellResults.length,

package/src/tools/resolve.ts

@@ -17,6 +17,7 @@
 import type { AgentToolResult, CustomMessage } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
+import { prompt } from "@oh-my-pi/pi-utils";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { parseXdUrl, XD_URL_PREFIX } from "../internal-urls/xd-protocol";
 import type { Theme } from "../modes/theme/theme";
@@ -36,6 +37,14 @@ export const RESOLVE_DEVICE_PATH = `${XD_URL_PREFIX}${RESOLVE_DEVICE_NAME}`;
 export const REJECT_DEVICE_PATH = `${XD_URL_PREFIX}${REJECT_DEVICE_NAME}`;
 export const PROPOSE_DEVICE_PATH = `${XD_URL_PREFIX}${PROPOSE_DEVICE_NAME}`;
 
+/**
+ * Model-visible banner prepended to a staged preview's tool result text. The
+ * TUI badge (`⟨proposed⟩`) never reaches the model, and preview diffs are
+ * byte-identical to applied-edit output — without this line the model reads
+ * the result as an already-applied change.
+ */
+export const PREVIEW_PENDING_NOTICE = `Staged as a proposal — files NOT modified yet. To apply: write a one-sentence reason to ${RESOLVE_DEVICE_PATH}. To discard: write to ${REJECT_DEVICE_PATH}.`;
+
 export type ResolutionDeviceName = typeof RESOLVE_DEVICE_NAME | typeof REJECT_DEVICE_NAME | typeof PROPOSE_DEVICE_NAME;
 
 /** Whether an xd:// device name is one of the plain-text resolution devices. */
@@ -204,7 +213,7 @@ export function buildResolveReminderMessage(sourceToolName: string): CustomMessa
 	return {
 		role: "custom",
 		customType: "resolve-reminder",
-		content: resolveReminderPrompt.trim(),
+		content: prompt.render(resolveReminderPrompt, { toolName: sourceToolName }).trim(),
 		display: false,
 		details: { toolName: sourceToolName },
 		attribution: "agent",

package/src/tools/todo.ts

@@ -524,7 +524,46 @@ function applyEntry(phases: TodoPhase[], entry: TodoOpEntryValue, errors: string
 	}
 }
 
-function applyParams(phases: TodoPhase[], params: TodoParams): { phases: TodoPhase[]; errors: string[] } {
+/**
+ * Infer a missing `op` from the raw argument shape. Only unambiguous shapes
+ * are inferred:
+ * - `list` → `init` (list is init-only)
+ * - `items` + `phase` → `append` (lazily creates the phase, so the result
+ *   matches a single-phase init when nothing exists yet)
+ * - bare `items` with no existing todos → `init` (nothing to overwrite)
+ * Targeting args alone (`task`/`phase`) map to several ops and stay an error.
+ */
+function inferTodoOp(args: Record<string, unknown>, hasExistingPhases: boolean): TodoOperation | undefined {
+	if (Array.isArray(args.list) && args.list.length > 0) return "init";
+	if (Array.isArray(args.items) && args.items.length > 0) {
+		if (typeof args.phase === "string" && args.phase) return "append";
+		if (!hasExistingPhases) return "init";
+	}
+	return undefined;
+}
+
+/**
+ * Validate execute-time arguments, repairing an omitted `op`. The tool sets
+ * `lenientArgValidation`, so the agent loop hands `execute()` the raw
+ * arguments when schema validation fails; the only failure repaired here is
+ * a missing `op` alongside an unambiguous payload (models routinely send
+ * `{list:[...]}` with no op). Anything else returns the schema error text
+ * for a normal model retry.
+ */
+function resolveTodoParams(raw: unknown, hasExistingPhases: boolean): TodoOpEntryValue | string {
+	const direct = todoSchema(raw);
+	if (!(direct instanceof type.errors)) return direct;
+	if (isRecord(raw) && raw.op === undefined) {
+		const inferred = inferTodoOp(raw, hasExistingPhases);
+		if (inferred) {
+			const repaired = todoSchema({ ...raw, op: inferred });
+			if (!(repaired instanceof type.errors)) return repaired;
+		}
+	}
+	return `Invalid todo arguments: ${direct.summary}`;
+}
+
+function applyParams(phases: TodoPhase[], params: TodoOpEntryValue): { phases: TodoPhase[]; errors: string[] } {
 	const errors: string[] = [];
 	const next = applyEntry(phases, params, errors);
 	normalizeInProgressTask(next);
@@ -534,7 +573,7 @@ function applyParams(phases: TodoPhase[], params: TodoParams): { phases: TodoPha
 /** Apply an array of `todo`-style ops to existing phases. Used by /todo slash command. */
 export function applyOpsToPhases(
 	currentPhases: TodoPhase[],
-	ops: TodoParams[],
+	ops: TodoOpEntryValue[],
 ): { phases: TodoPhase[]; errors: string[] } {
 	const errors: string[] = [];
 	let next = clonePhases(currentPhases);
@@ -731,6 +770,9 @@ export class TodoTool implements AgentTool<typeof todoSchema, TodoToolDetails> {
 	readonly parameters = todoSchema;
 	readonly concurrency = "exclusive";
 	readonly strict = true;
+	// Raw args reach execute() on schema failure; resolveTodoParams re-validates
+	// and repairs the one recoverable shape (missing `op`, unambiguous payload).
+	readonly lenientArgValidation = true;
 
 	readonly examples: readonly ToolExample<typeof todoSchema.infer>[] = [
 		{
@@ -789,11 +831,22 @@ export class TodoTool implements AgentTool<typeof todoSchema, TodoToolDetails> {
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<TodoToolDetails>> {
 		const previousPhases = clonePhases(this.session.getTodoPhases?.() ?? []);
+		const storage = this.session.getSessionFile() ? "session" : "memory";
+		const resolved = resolveTodoParams(params, previousPhases.length > 0);
+		if (typeof resolved === "string") {
+			return {
+				content: [{ type: "text", text: resolved }],
+				details: { phases: previousPhases, storage },
+				isError: true,
+			};
+		}
+		const entry = resolved;
+		const op = entry.op;
 		// Pure-view calls are reads: no normalization, no state write.
-		const readOnly = params.op === "view";
+		const readOnly = op === "view";
 		const { phases: updated, errors } = readOnly
 			? { phases: previousPhases, errors: [] as string[] }
-			: applyParams(clonePhases(previousPhases), params);
+			: applyParams(clonePhases(previousPhases), entry);
 		// A batch with any error is discarded wholesale: persisting a
 		// half-applied batch makes the natural retry hit "already exists" for
 		// the ops that did land. State and rendered summary stay at previous.
@@ -801,8 +854,7 @@ export class TodoTool implements AgentTool<typeof todoSchema, TodoToolDetails> {
 		const effective = failed ? previousPhases : updated;
 		const completedTasks = readOnly || failed ? [] : getCompletionTransitions(previousPhases, updated);
 		if (!readOnly && !failed) this.session.setTodoPhases?.(updated);
-		const storage = this.session.getSessionFile() ? "session" : "memory";
-		const details: TodoToolDetails = { op: params.op, phases: effective, storage };
+		const details: TodoToolDetails = { op, phases: effective, storage };
 		if (completedTasks.length > 0) details.completedTasks = completedTasks;
 
 		return {

package/src/web/search/index.ts

@@ -27,6 +27,7 @@ import {
 	type SearchProvider,
 	type SearchProviderCandidate,
 } from "./provider";
+import { applyQueryConstraints, parseSearchQuery } from "./query";
 import { renderSearchCall, renderSearchResult, type SearchRenderDetails } from "./render";
 import type { SearchProviderId, SearchResponse } from "./types";
 import { SearchProviderError } from "./types";
@@ -57,9 +58,12 @@ function formatCount(label: string, count: number): string {
 	return `${count} ${label}${count === 1 ? "" : "s"}`;
 }
 
-/** Format response for LLM consumption */
-function formatForLLM(response: SearchResponse): string {
+/** Format response for LLM consumption. `notes` lead the output (e.g. relaxed-constraint warnings). */
+function formatForLLM(response: SearchResponse, notes: readonly string[] = []): string {
 	const parts: string[] = [];
+	for (const note of notes) {
+		parts.push(`Note: ${note}`);
+	}
 
 	if (response.answer) {
 		parts.push(response.answer);
@@ -141,6 +145,8 @@ async function executeSearch(
 		candidates = resolveProviderCandidates();
 	}
 
+	const parsedQuery = parseSearchQuery(params.query);
+
 	// Invariant across providers; read once and tolerate an uninitialized
 	// Settings singleton (e.g. `omp q ...` CLI path, unit tests) so the
 	// provider-fallback loop never aborts before any provider runs.
@@ -182,6 +188,7 @@ async function executeSearch(
 
 			const response = await provider.search({
 				query: params.query,
+				parsedQuery,
 				limit: params.limit,
 				recency: params.recency,
 				systemPrompt: webSearchSystemPrompt,
@@ -196,15 +203,31 @@ async function executeSearch(
 				geminiModel,
 			});
 
-			if (!hasRenderableSearchContent(response)) {
+			// Lenient constraint pass over whatever the provider returned: enforce
+			// site:/inurl:/intitle:/filetype:/date directives the provider could
+			// not (or only partially) honor natively, relaxing any dimension that
+			// would wipe out every result. Citations/answer text stay untouched.
+			let finalResponse = response;
+			const constraintNotes: string[] = [];
+			if (parsedQuery.hasConstraints && response.sources.length > 0) {
+				const filtered = applyQueryConstraints(response.sources, parsedQuery);
+				if (filtered.sources.length !== response.sources.length) {
+					finalResponse = { ...response, sources: filtered.sources };
+				}
+				for (const label of filtered.dropped) {
+					constraintNotes.push(`no results matched \`${label}\`; the constraint was relaxed`);
+				}
+			}
+
+			if (!hasRenderableSearchContent(finalResponse)) {
 				throw new SearchProviderError(provider.id, `${provider.label} returned no renderable search content.`, 204);
 			}
 
-			const text = formatForLLM(response);
+			const text = formatForLLM(finalResponse, constraintNotes);
 
 			return {
 				content: [{ type: "text" as const, text }],
-				details: { response },
+				details: { response: finalResponse },
 			};
 		} catch (error) {
 			// Surface user-initiated cancellation immediately so the session sees