@oh-my-pi/pi-coding-agent 17.2.10 → 17.2.11

package/src/tools/bash.ts

@@ -49,7 +49,7 @@ import {
 	previewWindowRows,
 	replaceTabs,
 } from "./render-utils";
-import { tokenizeShellSegments } from "./shell-tokenize";
+import { extractLeadingCdTarget, tokenizeShellSegments } from "./shell-tokenize";
 import { ToolAbortError, ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout, TOOL_TIMEOUTS } from "./tool-timeouts";
@@ -960,17 +960,16 @@ export class BashTool implements AgentTool<typeof bashSchemaBase | typeof bashSc
 		let command = rawCommand;
 		const env = normalizeBashEnv(rawEnv);
 
-		// Extract leading `cd <path> && ...` into cwd when the model ignores the cwd parameter.
-		// Constrained to a single line so a `&&` that sits on a later line of a multiline
-		// script can't pull the entire script into the "cwd" capture.
+		// Extract a leading `cd <path> && ...` into cwd when the model ignores the
+		// cwd parameter. The scanner captures only a single path token and defers
+		// to the shell for anything else (redirects, extra args, shell expansion),
+		// so it never absorbs shell syntax like `cd /tmp 2>/dev/null && ...` into
+		// the structured cwd. Constrained to a top-level `&&` on the first line.
 		if (!cwd) {
-			const cdMatch = command.match(/^cd[ \t]+((?:[^&\\\n\r]|\\.)+?)[ \t]*&&[ \t]*/);
-			// Skip extraction when the path needs shell expansion ($VAR, $(...),
-			// backticks) — resolveToCwd only expands `~`, so routing those through
-			// cwd would reject commands the shell itself handles fine.
-			if (cdMatch && !/[$`(]/.test(cdMatch[1])) {
-				cwd = cdMatch[1].trim().replace(/^["']|["']$/g, "");
-				command = command.slice(cdMatch[0].length);
+			const cd = extractLeadingCdTarget(command);
+			if (cd) {
+				cwd = cd.path;
+				command = cd.rest;
 			}
 		}
 		if (asyncRequested && !this.#asyncEnabled) {

package/src/tools/debug.ts

@@ -505,7 +505,7 @@ const ADAPTER_UNAVAILABLE_MESSAGES: Readonly<Record<string, string>> = {
 	dlv: "adapter 'dlv' is not available: install with 'go install github.com/go-delve/delve/cmd/dlv@latest'",
 	rdbg: "adapter 'rdbg' is not available: install with 'gem install debug'",
 	"js-debug-adapter":
-		"adapter 'js-debug-adapter' is not available: install vscode-js-debug with Mason or set JS_DEBUG_DAP_SERVER to dapDebugServer.js",
+		"adapter 'js-debug-adapter' is not available: download it from https://github.com/microsoft/vscode-js-debug",
 };
 
 const ADAPTER_CANONICAL_COMMANDS: Readonly<Record<string, string>> = {

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

@@ -8,6 +8,7 @@
  * @see https://datatracker.ietf.org/doc/html/rfc8927
  */
 
+import { isRecord } from "@oh-my-pi/pi-utils";
 import type { JTDPrimitive } from "./jtd-utils.js";
 import {
 	isJTDDiscriminator,
@@ -134,6 +135,18 @@ function convertSchema(schema: unknown): unknown {
 	return {};
 }
 
+const jtdOnlyPrimitiveTypes: Record<string, true> = {
+	timestamp: true,
+	float32: true,
+	float64: true,
+	int8: true,
+	uint8: true,
+	int16: true,
+	uint16: true,
+	int32: true,
+	uint32: true,
+};
+
 /**
  * Detect if a schema is JTD format (vs JSON Schema).
  *
@@ -155,11 +168,8 @@ export function isJTDSchema(schema: unknown): boolean {
 	if ("ref" in obj) return true;
 
 	// JTD type primitives (JSON Schema doesn't have int32, float64, etc.)
-	if ("type" in obj) {
-		const jtdPrimitives = ["timestamp", "float32", "float64", "int8", "uint8", "int16", "uint16", "int32", "uint32"];
-		if (jtdPrimitives.includes(obj.type as string)) {
-			return true;
-		}
+	if (typeof obj.type === "string" && Object.hasOwn(jtdOnlyPrimitiveTypes, obj.type)) {
+		return true;
 	}
 
 	// JTD properties form without type: "object" (JSON Schema requires it)
@@ -170,36 +180,128 @@ export function isJTDSchema(schema: unknown): boolean {
 	return false;
 }
 
-function normalizeMixedSchemaNode(schema: unknown): unknown {
-	if (schema === null || typeof schema !== "object") {
-		return schema;
+function isUnambiguousJTDSchema(schema: unknown): boolean {
+	if (!isRecord(schema)) return false;
+
+	if (isRecord(schema.elements) || isRecord(schema.values) || isRecord(schema.optionalProperties)) {
+		return true;
+	}
+	if (typeof schema.ref === "string") return true;
+	if (typeof schema.type === "string" && Object.hasOwn(jtdOnlyPrimitiveTypes, schema.type)) {
+		return true;
+	}
+	if (typeof schema.discriminator !== "string" || !isRecord(schema.mapping)) {
+		return false;
 	}
 
-	if (Array.isArray(schema)) {
-		return schema.map(item => normalizeMixedSchemaNode(item));
+	for (const key in schema.mapping) {
+		if (!Object.hasOwn(schema.mapping, key)) continue;
+		const mapping = schema.mapping[key];
+		if (!isRecord(mapping)) return false;
+
+		let hasSchemaProperties = false;
+		if (Object.hasOwn(mapping, "properties")) {
+			if (!isRecord(mapping.properties)) return false;
+			hasSchemaProperties = true;
+		}
+		if (Object.hasOwn(mapping, "optionalProperties")) {
+			if (!isRecord(mapping.optionalProperties)) return false;
+			hasSchemaProperties = true;
+		}
+		if (!hasSchemaProperties) return false;
 	}
 
-	if (isJTDSchema(schema)) {
-		// `convertSchema` is itself fully recursive and emits pure JSON Schema, so
-		// re-walking the result with `normalizeMixedSchemaNode` is unnecessary and
-		// unsafe: it would treat user-named properties whose keys happen to be JTD
-		// keywords (e.g. `ref`, `elements`) as nested JTD forms (#1345).
-		return convertSchema(schema);
+	return true;
+}
+
+function normalizeJsonSchemaArray(value: unknown): unknown {
+	if (!Array.isArray(value)) return value;
+
+	let normalized: unknown[] | undefined;
+	for (let index = 0; index < value.length; index++) {
+		const item = value[index];
+		const converted = normalizeJsonSchemaNode(item);
+		if (converted === item) continue;
+		normalized ??= value.slice();
+		normalized[index] = converted;
+	}
+	return normalized ?? value;
+}
+
+function normalizeJsonSchemaMap(value: unknown): unknown {
+	if (!isRecord(value)) return value;
+
+	let normalized: Record<string, unknown> | undefined;
+	for (const key in value) {
+		if (!Object.hasOwn(value, key)) continue;
+		const item = value[key];
+		const converted = normalizeJsonSchemaNode(item);
+		if (converted === item) continue;
+		normalized ??= { ...value };
+		normalized[key] = converted;
 	}
+	return normalized ?? value;
+}
 
-	const normalized: Record<string, unknown> = {};
-	for (const [key, value] of Object.entries(schema)) {
-		normalized[key] = normalizeMixedSchemaNode(value);
+function normalizeJsonSchemaNode(schema: unknown): unknown {
+	if (!isRecord(schema)) return schema;
+	if (isUnambiguousJTDSchema(schema)) return convertSchema(schema);
+
+	let normalized: Record<string, unknown> | undefined;
+	for (const key in schema) {
+		if (!Object.hasOwn(schema, key)) continue;
+
+		const value = schema[key];
+		let converted: unknown;
+		switch (key) {
+			case "not":
+			case "if":
+			case "then":
+			case "else":
+			case "items":
+			case "contains":
+			case "propertyNames":
+			case "additionalProperties":
+			case "unevaluatedProperties":
+			case "unevaluatedItems":
+			case "contentSchema":
+				converted = normalizeJsonSchemaNode(value);
+				break;
+			case "allOf":
+			case "anyOf":
+			case "oneOf":
+			case "prefixItems":
+				converted = normalizeJsonSchemaArray(value);
+				break;
+			case "properties":
+			case "patternProperties":
+			case "$defs":
+			case "definitions":
+			case "dependentSchemas":
+				converted = normalizeJsonSchemaMap(value);
+				break;
+			default:
+				continue;
+		}
+
+		if (converted === value) continue;
+		normalized ??= { ...schema };
+		normalized[key] = converted;
 	}
 
-	return normalized;
+	return normalized ?? schema;
 }
+
 /**
  * Convert JTD schema to JSON Schema.
  * If already JSON Schema, returns as-is.
  */
 export function jtdToJsonSchema(schema: unknown): unknown {
-	return normalizeMixedSchemaNode(schema);
+	if (isJTDSchema(schema)) {
+		// convertSchema is recursive; re-walking its JSON Schema output caused #1345.
+		return convertSchema(schema);
+	}
+	return normalizeJsonSchemaNode(schema);
 }
 
 /**

package/src/tools/read.ts

@@ -2497,6 +2497,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		const imageMetadata = await readImageMetadata(absolutePath);
 		const mimeType = imageMetadata?.mimeType;
 		const ext = path.extname(absolutePath).toLowerCase();
+		const resolvedDisplayPath = formatPathRelativeToCwd(absolutePath, this.session.cwd);
 		const shouldConvertWithMarkit = CONVERTIBLE_EXTENSIONS.has(ext);
 
 		// Profiler reports (macOS `sample` call trees, V8 `.cpuprofile` JSON):
@@ -2541,7 +2542,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				fileSize,
 			}));
 		} else if (isNotebookPath(absolutePath) && !isRawSelector(parsed)) {
-			const notebookText = await readEditableNotebookText(absolutePath, localReadPath);
+			const notebookText = await readEditableNotebookText(absolutePath, resolvedDisplayPath);
 			if (isMultiRange(parsed) && parsed.kind === "lines") {
 				return this.#buildInMemoryMultiRangeResult(notebookText, parsed.ranges, {
 					details: { resolvedPath: absolutePath },
@@ -2560,7 +2561,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const result = await convertFileWithMarkit(absolutePath, signal);
 			if (result.ok) {
 				const renderedContent =
-					ext === ".pdf" ? rewritePdfImagePlaceholders(result.content, localReadPath) : result.content;
+					ext === ".pdf" ? rewritePdfImagePlaceholders(result.content, resolvedDisplayPath) : result.content;
 				// Route the converted markdown through the in-memory text builder
 				// so line-range selectors (`file.pdf:50-100`, `:5-16,40-80`) and
 				// raw mode apply against the converted output. Without this,
@@ -2603,7 +2604,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				return toolResult<ReadToolDetails>({ resolvedPath: absolutePath, suffixResolution })
 					.text(
 						prependSuffixResolutionNotice(
-							`[Cannot read binary file '${formatPathRelativeToCwd(absolutePath, this.session.cwd)}' (${formatBytes(fileSize)}); not valid UTF-8 text. Use ':raw' to read bytes verbatim.]`,
+							`[Cannot read binary file '${resolvedDisplayPath}' (${formatBytes(fileSize)}); not valid UTF-8 text. Use ':raw' to read bytes verbatim.]`,
 							suffixResolution,
 						),
 					)
@@ -2620,7 +2621,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				if (summary?.parsed && summary.elided) {
 					const renderedSummary = this.#renderSummary(summary);
 					const footer = formatSummaryElisionFooter(
-						localReadPath,
+						resolvedDisplayPath,
 						renderedSummary.elidedRanges,
 						renderedSummary.elidedLines,
 					);

package/src/tools/shell-tokenize.ts

@@ -211,3 +211,101 @@ export function extractFlatShellCommandSegments(command: string): FlatShellComma
 	pushSegment(command.length);
 	return segments;
 }
+
+/**
+ * Shell metacharacters that end an unquoted `cd` target token. A redirect,
+ * extra argument, or any operator in this set means the leading construct is
+ * more than a bare `cd <path>`, so extraction must bail.
+ */
+const CD_TARGET_TERMINATORS: Record<string, true> = {
+	" ": true,
+	"\t": true,
+	"\n": true,
+	"\r": true,
+	"&": true,
+	"|": true,
+	";": true,
+	"<": true,
+	">": true,
+	"(": true,
+	")": true,
+};
+
+/**
+ * Parses a leading `cd <path> && ...` prefix so the bash tool can route the
+ * target through its structured `cwd` parameter when the model omits it.
+ *
+ * Returns the single path token (quotes and backslash escapes resolved to their
+ * literal value) and the command remainder after the top-level `&&`, or `null`
+ * when the command does not begin with exactly `cd`, one path token, and a
+ * top-level `&&`. The scanner deliberately bails on anything else in the prefix
+ * — redirects (`cd /tmp 2>/dev/null && ...`), extra arguments, or paths needing
+ * shell expansion (`$`, backticks, `(`) — leaving the whole command for the
+ * shell instead of absorbing shell syntax into `cwd`.
+ */
+export function extractLeadingCdTarget(command: string): { path: string; rest: string } | null {
+	const prefix = /^cd[ \t]+/.exec(command);
+	if (!prefix) return null;
+	let i = prefix[0].length;
+	let path = "";
+	let inSingle = false;
+	let inDouble = false;
+	for (; i < command.length; i++) {
+		const ch = command[i];
+		if (inSingle) {
+			if (ch === "'") {
+				inSingle = false;
+				continue;
+			}
+			path += ch;
+			continue;
+		}
+		if (inDouble) {
+			if (ch === "\\" && i + 1 < command.length) {
+				const next = command[i + 1];
+				// A line continuation crosses the first physical line. Leave it to
+				// the shell rather than turning the escaped newline into cwd text.
+				if (next === "\n" || next === "\r") return null;
+				if (next === '"' || next === "\\" || next === "$" || next === "`") {
+					path += next;
+					i++;
+					continue;
+				}
+			}
+			if (ch === '"') {
+				inDouble = false;
+				continue;
+			}
+			path += ch;
+			continue;
+		}
+		if (ch === "'") {
+			inSingle = true;
+			continue;
+		}
+		if (ch === '"') {
+			inDouble = true;
+			continue;
+		}
+		if (ch === "\\" && i + 1 < command.length) {
+			// Preserve shell line-continuation semantics by declining extraction.
+			if (command[i + 1] === "\n" || command[i + 1] === "\r") return null;
+			path += command[i + 1];
+			i++;
+			continue;
+		}
+		if (CD_TARGET_TERMINATORS[ch]) break;
+		path += ch;
+	}
+	// Unterminated quote or empty target: leave the command for the shell.
+	if (inSingle || inDouble || path.length === 0) return null;
+	// A path needing shell expansion can't be resolved literally through cwd.
+	if (/[$`(]/.test(path)) return null;
+	// Skip inter-token whitespace, then require a top-level `&&` (a single `&`,
+	// `||`, `;`, `|`, or a redirect all mean this is not a bare `cd <path>`).
+	while (command[i] === " " || command[i] === "\t") i++;
+	if (command[i] !== "&" || command[i + 1] !== "&") return null;
+	i += 2;
+	while (command[i] === " " || command[i] === "\t") i++;
+	return { path, rest: command.slice(i) };
+}

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

@@ -464,7 +464,7 @@ export class ExaProvider extends SearchProvider {
 
 	#settingsAllowSearch(): boolean {
 		try {
-			if (settings.get("exa.enabled") === false || settings.get("exa.enableSearch") === false) {
+			if (settings.get("exa.enabled") === false) {
 				return false;
 			}
 		} catch {