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

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-archive.ts

@@ -0,0 +1,209 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { TextContent } from "@oh-my-pi/pi-ai";
+import type { ToolSession } from "../sdk";
+import { truncateHead } from "../session/streaming-output";
+import { type ArchiveReader, formatArchiveEntryLines, openArchive, parseArchivePathCandidates } from "../utils/zip";
+import { applyListLimit } from "./list-limit";
+import { resolveReadPath } from "./path-utils";
+import type { ReadToolDetails } from "./read";
+import {
+	buildInMemoryMultiRangeResult,
+	buildInMemoryTextResult,
+	decodeUtf8Text,
+	markMarkdownContentType,
+	prependSuffixResolutionNotice,
+} from "./read-format";
+import {
+	findSuffixMatchCached,
+	isNotFoundError,
+	isRemoteMountPath,
+	type SuffixMatchCache,
+} from "./read-path-resolution";
+import { isMultiRange, isRawSelector, type ParsedSelector, parseSel, selToOffsetLimit } from "./read-selector";
+import { formatBytes } from "./render-utils";
+import { ToolError, throwIfAborted } from "./tool-errors";
+import { toolResult } from "./tool-result";
+
+interface ResolvedArchiveReadPath {
+	absolutePath: string;
+	archiveSubPath: string;
+	suffixResolution?: { from: string; to: string };
+}
+export async function resolveArchiveReadPath(
+	session: ToolSession,
+	readPath: string,
+	suffixCache: SuffixMatchCache,
+	signal?: AbortSignal,
+): Promise<ResolvedArchiveReadPath | null> {
+	const candidates = parseArchivePathCandidates(readPath);
+	for (const candidate of candidates) {
+		let absolutePath = resolveReadPath(candidate.archivePath, session.cwd);
+		let suffixResolution: { from: string; to: string } | undefined;
+
+		try {
+			const stat = await Bun.file(absolutePath).stat();
+			if (stat.isDirectory()) continue;
+			return {
+				absolutePath,
+				archiveSubPath: candidate.archivePath === readPath ? "" : candidate.subPath,
+				suffixResolution,
+			};
+		} catch (error) {
+			if (!isNotFoundError(error) || isRemoteMountPath(absolutePath)) continue;
+
+			const suffixMatch = await findSuffixMatchCached(session, suffixCache, candidate.archivePath, signal);
+			if (!suffixMatch) continue;
+
+			try {
+				const retryStat = await Bun.file(suffixMatch.absolutePath).stat();
+				if (retryStat.isDirectory()) continue;
+
+				absolutePath = suffixMatch.absolutePath;
+				suffixResolution = { from: candidate.archivePath, to: suffixMatch.displayPath };
+				return {
+					absolutePath,
+					archiveSubPath: candidate.archivePath === readPath ? "" : candidate.subPath,
+					suffixResolution,
+				};
+			} catch (retryError) {
+				if (!isNotFoundError(retryError)) {
+					throw retryError;
+				}
+			}
+		}
+	}
+
+	return null;
+}
+async function readArchiveDirectory(
+	archive: ArchiveReader,
+	archivePath: string,
+	subPath: string,
+	offset: number | undefined,
+	limit: number | undefined,
+	details: ReadToolDetails,
+	signal?: AbortSignal,
+): Promise<AgentToolResult<ReadToolDetails>> {
+	const DEFAULT_LIMIT = 500;
+	const effectiveLimit = limit ?? DEFAULT_LIMIT;
+	const allEntries = archive.listDirectory(subPath);
+	// `offset` is 1-indexed (line-selector semantics): `a.zip:dir:50` starts
+	// the listing at the 50th entry instead of being silently ignored.
+	const entries = offset !== undefined && offset > 1 ? allEntries.slice(offset - 1) : allEntries;
+
+	const listLimit = applyListLimit(entries, { limit: effectiveLimit });
+	const limitedEntries = listLimit.items;
+	const limitMeta = listLimit.meta;
+
+	for (let index = 0; index < limitedEntries.length; index++) {
+		throwIfAborted(signal);
+	}
+	const results = formatArchiveEntryLines(limitedEntries);
+
+	const output = results.length > 0 ? results.join("\n") : "(empty archive directory)";
+	const text = prependSuffixResolutionNotice(output, details.suffixResolution);
+	const truncation = truncateHead(text, { maxLines: Number.MAX_SAFE_INTEGER });
+	const directoryDetails: ReadToolDetails = { ...details, isDirectory: true };
+	const resultBuilder = toolResult<ReadToolDetails>(directoryDetails).text(truncation.content);
+	resultBuilder.sourcePath(archivePath).limits({ resultLimit: limitMeta.resultLimit?.reached });
+	if (truncation.truncated) {
+		directoryDetails.truncation = truncation;
+		resultBuilder.truncation(truncation, { direction: "head" });
+	}
+	return resultBuilder.done();
+}
+
+export async function readArchive(
+	session: ToolSession,
+	readPath: string,
+	parsedSel: ParsedSelector,
+	resolvedArchivePath: ResolvedArchiveReadPath,
+	signal?: AbortSignal,
+): Promise<AgentToolResult<ReadToolDetails>> {
+	throwIfAborted(signal);
+	const archive = await openArchive(resolvedArchivePath.absolutePath);
+	throwIfAborted(signal);
+
+	const details: ReadToolDetails = markMarkdownContentType(
+		session,
+		{
+			resolvedPath: resolvedArchivePath.absolutePath,
+			suffixResolution: resolvedArchivePath.suffixResolution,
+		},
+		resolvedArchivePath.archiveSubPath,
+	);
+
+	let archiveSubPath = resolvedArchivePath.archiveSubPath;
+	let sel = parsedSel;
+	let node = archive.getNode(archiveSubPath);
+	if (!node && archiveSubPath) {
+		// `archive.zip:500` / `archive.zip:raw`: the whole subPath is a
+		// selector on the archive root, not a member name. Member names take
+		// precedence (getNode above); fall back to root + selector.
+		const wholeSel = parseSel(archiveSubPath);
+		if (wholeSel.kind !== "none") {
+			node = archive.getNode("");
+			archiveSubPath = "";
+			sel = wholeSel;
+		}
+	}
+	if (!node) {
+		throw new ToolError(`Path '${readPath}' not found inside archive`);
+	}
+
+	if (node.isDirectory) {
+		if (isMultiRange(sel)) {
+			throw new ToolError("Multi-range line selectors are not supported for archive directory listings.");
+		}
+		const { offset, limit } = selToOffsetLimit(sel);
+		return readArchiveDirectory(
+			archive,
+			resolvedArchivePath.absolutePath,
+			archiveSubPath,
+			offset,
+			limit,
+			details,
+			signal,
+		);
+	}
+
+	const entry = await archive.readFile(archiveSubPath);
+	const text = decodeUtf8Text(entry.bytes);
+	if (text === null) {
+		return toolResult<ReadToolDetails>(details)
+			.text(
+				prependSuffixResolutionNotice(
+					`[Cannot read binary archive entry '${entry.path}' (${formatBytes(entry.size)})]`,
+					resolvedArchivePath.suffixResolution,
+				),
+			)
+			.sourcePath(resolvedArchivePath.absolutePath)
+			.done();
+	}
+
+	// Archive members are immutable: there is no edit path for bytes inside
+	// an archive, and a hashline tag keyed to the archive file would invite
+	// (and fail) edits while clobbering sibling members' snapshots.
+	const raw = isRawSelector(sel);
+	const result =
+		isMultiRange(sel) && sel.kind === "lines"
+			? buildInMemoryMultiRangeResult(session, text, sel.ranges, {
+					details,
+					sourcePath: resolvedArchivePath.absolutePath,
+					entityLabel: "archive entry",
+					raw,
+					immutable: true,
+				})
+			: buildInMemoryTextResult(session, text, selToOffsetLimit(sel).offset, selToOffsetLimit(sel).limit, {
+					details,
+					sourcePath: resolvedArchivePath.absolutePath,
+					entityLabel: "archive entry",
+					raw,
+					immutable: true,
+				});
+	const firstText = result.content.find((content): content is TextContent => content.type === "text");
+	if (firstText) {
+		firstText.text = prependSuffixResolutionNotice(firstText.text, resolvedArchivePath.suffixResolution);
+	}
+	return result;
+}