@oh-my-pi/pi-coding-agent 14.8.0 → 14.9.0

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -1,4 +1,7 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
 import * as path from "node:path";
+import * as url from "node:url";
 
 const LEGACY_PI_PACKAGE_MAP = {
 	"@mariozechner/pi-agent-core": "@oh-my-pi/pi-agent-core",
@@ -54,6 +57,10 @@ function getResolvedSpecifier(specifier: string): string {
 	return resolved;
 }
 
+function toImportSpecifier(resolvedPath: string): string {
+	return url.pathToFileURL(resolvedPath).href;
+}
+
 function rewriteLegacyPiImports(source: string): string {
 	return source.replace(
 		LEGACY_PI_IMPORT_SPECIFIER_REGEX,
@@ -63,42 +70,118 @@ function rewriteLegacyPiImports(source: string): string {
 				return match;
 			}
 
-			return `${prefix}${getResolvedSpecifier(remappedSpecifier)}${suffix}`;
+			return `${prefix}${toImportSpecifier(getResolvedSpecifier(remappedSpecifier))}${suffix}`;
 		},
 	);
 }
 
-// Match `from "..."`, `from '...'`, `import("...")`, `import('...')` import specifiers.
+// Match static `from "..."` / `from '...'` import specifiers.
+const STATIC_IMPORT_SPECIFIER_REGEX = /(from\s+["'])([^"']+)(["'])/g;
+// Match static imports plus dynamic `import("...")` / `import('...')` specifiers.
 const ANY_IMPORT_SPECIFIER_REGEX = /((?:from\s+|import\s*\(\s*)["'])([^"']+)(["'])/g;
 
-/**
- * Resolves bare module specifiers in a legacy-namespaced extension source file
- * to absolute paths anchored at the extension's own directory. Without this,
- * imports inside files loaded via the `omp-legacy-pi-file:` namespace bypass
- * Node-style node_modules lookup, so an extension cannot use its own deps.
- * Relative paths and already-resolved absolute paths are left untouched.
- */
+/** Resolve bare imports against the extension directory before loading mirrored legacy Pi files. */
+function isUrlLikeSpecifier(specifier: string): boolean {
+	return /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(specifier);
+}
+
+function shouldPreserveImportSpecifier(specifier: string): boolean {
+	return specifier.startsWith(".") || path.isAbsolute(specifier) || isUrlLikeSpecifier(specifier);
+}
+
+function toRewrittenImportSpecifier(resolvedPath: string): string {
+	return isUrlLikeSpecifier(resolvedPath) ? resolvedPath : toImportSpecifier(resolvedPath);
+}
+
 function rewriteBareImportsForLegacyExtension(source: string, importerPath: string): string {
 	const importerDir = path.dirname(importerPath);
 	return source.replace(ANY_IMPORT_SPECIFIER_REGEX, (match, prefix: string, specifier: string, suffix: string) => {
 		// Skip relative, absolute, URL-style, and already-resolved Node specifiers.
-		if (
-			specifier.startsWith(".") ||
-			specifier.startsWith("/") ||
-			specifier.startsWith("node:") ||
-			specifier.includes("://")
-		) {
+		if (shouldPreserveImportSpecifier(specifier)) {
 			return match;
 		}
 		try {
 			const resolved = Bun.resolveSync(specifier, importerDir);
-			return `${prefix}${resolved}${suffix}`;
+			return `${prefix}${toRewrittenImportSpecifier(resolved)}${suffix}`;
 		} catch {
 			return match;
 		}
 	});
 }
 
+interface LegacyPiMirrorState {
+	root: string;
+	seen: Map<string, string>;
+}
+
+function getMirrorPath(sourcePath: string, state: LegacyPiMirrorState): string {
+	const extension = path.extname(sourcePath) || ".js";
+	const digest = Bun.hash(sourcePath).toString(36);
+	return path.join(state.root, `${digest}${extension}`);
+}
+
+async function rewriteRelativeImportsForLegacyExtension(
+	source: string,
+	importerPath: string,
+	state: LegacyPiMirrorState,
+): Promise<string> {
+	const replacements = new Map<string, string>();
+
+	for (const match of source.matchAll(STATIC_IMPORT_SPECIFIER_REGEX)) {
+		const specifier = match[2];
+		if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+			continue;
+		}
+
+		const resolved = Bun.resolveSync(specifier, path.dirname(importerPath));
+		const mirrored = await mirrorLegacyPiFile(resolved, state);
+		replacements.set(specifier, toImportSpecifier(mirrored));
+	}
+
+	if (replacements.size === 0) {
+		return source;
+	}
+
+	return source.replace(STATIC_IMPORT_SPECIFIER_REGEX, (match, prefix: string, specifier: string, suffix: string) => {
+		const replacement = replacements.get(specifier);
+		return replacement ? `${prefix}${replacement}${suffix}` : match;
+	});
+}
+
+async function rewriteLegacyPiImportsForRuntime(
+	source: string,
+	importerPath: string,
+	state: LegacyPiMirrorState,
+): Promise<string> {
+	const withRelativeResolved = await rewriteRelativeImportsForLegacyExtension(source, importerPath, state);
+	const withLegacyRemap = rewriteLegacyPiImports(withRelativeResolved);
+	return rewriteBareImportsForLegacyExtension(withLegacyRemap, importerPath);
+}
+
+async function mirrorLegacyPiFile(sourcePath: string, state: LegacyPiMirrorState): Promise<string> {
+	const resolvedPath = path.resolve(sourcePath);
+	const cached = state.seen.get(resolvedPath);
+	if (cached) {
+		return cached;
+	}
+
+	const mirrorPath = getMirrorPath(resolvedPath, state);
+	state.seen.set(resolvedPath, mirrorPath);
+
+	const raw = await Bun.file(resolvedPath).text();
+	const rewritten = await rewriteLegacyPiImportsForRuntime(raw, resolvedPath, state);
+	await Bun.write(mirrorPath, rewritten);
+	return mirrorPath;
+}
+
+export async function loadLegacyPiModule(resolvedPath: string): Promise<unknown> {
+	const root = path.join(os.tmpdir(), "omp-legacy-pi-file", Bun.hash(resolvedPath).toString(36));
+	await fs.rm(root, { recursive: true, force: true });
+	const state: LegacyPiMirrorState = { root, seen: new Map() };
+	const mirroredEntry = await mirrorLegacyPiFile(resolvedPath, state);
+	return import(`${toImportSpecifier(mirroredEntry)}?mtime=${Date.now()}`);
+}
+
 function getLoader(path: string): "js" | "jsx" | "ts" | "tsx" {
 	if (path.endsWith(".tsx")) {
 		return "tsx";
@@ -150,10 +233,6 @@ export function installLegacyPiSpecifierShim(): void {
 
 			build.onLoad({ filter: /\.[cm]?[jt]sx?$/, namespace: LEGACY_PI_FILE_NAMESPACE }, async args => {
 				const raw = await Bun.file(args.path).text();
-				// Bare specifiers (e.g. "lodash", "@scope/pkg/sub") imported from a legacy-namespaced
-				// extension file would otherwise bypass Node-style node_modules lookup because the
-				// importer lives in a custom namespace. Pre-resolve them to absolute paths so the
-				// extension's own node_modules are honored.
 				const withLegacyRemap = rewriteLegacyPiImports(raw);
 				const withBareResolved = rewriteBareImportsForLegacyExtension(withLegacyRemap, args.path);
 				return {

package/src/hashline/anchors.ts

@@ -0,0 +1,113 @@
+import { formatCodeFrameLine } from "../tools/render-utils";
+import { MISMATCH_CONTEXT } from "./constants";
+import { computeLineHash, describeAnchorExamples, HL_ANCHOR_RE_RAW, HL_BODY_SEP } from "./hash";
+import type { HashMismatch } from "./types";
+
+const HL_HASH_HINT_RE = /^[a-z]{2}$/i;
+const HL_ANCHOR_EXAMPLES = describeAnchorExamples("160");
+const PARSE_TAG_RE = new RegExp(`^${HL_ANCHOR_RE_RAW}`);
+
+export function formatFullAnchorRequirement(raw?: string): string {
+	const suffix = typeof raw === "string" ? raw.trim() : "";
+	const hashOnlyHint = HL_HASH_HINT_RE.test(suffix)
+		? ` It looks like you supplied only the hash suffix (${JSON.stringify(suffix)}). ` +
+			`Copy the full anchor exactly as shown (for example, "160${suffix}").`
+		: "";
+	const received = raw === undefined ? "" : ` Received ${JSON.stringify(raw)}.`;
+	return (
+		`the full anchor exactly as shown by read/search output ` +
+		`(line number + hash, for example ${HL_ANCHOR_EXAMPLES})${received}${hashOnlyHint}`
+	);
+}
+
+export function parseTag(ref: string): { line: number; hash: string } {
+	const match = ref.match(PARSE_TAG_RE);
+	if (!match) {
+		throw new Error(`Invalid line reference. Expected ${formatFullAnchorRequirement(ref)}.`);
+	}
+	const line = Number.parseInt(match[1], 10);
+	if (line < 1) throw new Error(`Line number must be >= 1, got ${line} in "${ref}".`);
+	return { line, hash: match[2] };
+}
+
+function getMismatchDisplayLines(mismatches: HashMismatch[], fileLines: string[]): number[] {
+	const displayLines = new Set<number>();
+	for (const mismatch of mismatches) {
+		const lo = Math.max(1, mismatch.line - MISMATCH_CONTEXT);
+		const hi = Math.min(fileLines.length, mismatch.line + MISMATCH_CONTEXT);
+		for (let lineNum = lo; lineNum <= hi; lineNum++) displayLines.add(lineNum);
+	}
+	return [...displayLines].sort((a, b) => a - b);
+}
+
+export class HashlineMismatchError extends Error {
+	readonly remaps: ReadonlyMap<string, string>;
+
+	constructor(
+		public readonly mismatches: HashMismatch[],
+		public readonly fileLines: string[],
+	) {
+		super(HashlineMismatchError.formatMessage(mismatches, fileLines));
+		this.name = "HashlineMismatchError";
+
+		const remaps = new Map<string, string>();
+		for (const mismatch of mismatches) {
+			const actual = computeLineHash(mismatch.line, fileLines[mismatch.line - 1] ?? "");
+			remaps.set(`${mismatch.line}${mismatch.expected}`, `${mismatch.line}${actual}`);
+		}
+		this.remaps = remaps;
+	}
+
+	get displayMessage(): string {
+		return HashlineMismatchError.formatDisplayMessage(this.mismatches, this.fileLines);
+	}
+
+	private static rejectionHeader(mismatches: HashMismatch[]): string[] {
+		const noun = mismatches.length > 1 ? "lines have" : "line has";
+		return [
+			`Edit rejected: ${mismatches.length} ${noun} changed since the last read (marked *).`,
+			"The edit was NOT applied, please use the updated file content shown below, and issue another edit tool-call.",
+		];
+	}
+
+	static formatDisplayMessage(mismatches: HashMismatch[], fileLines: string[]): string {
+		const mismatchSet = new Set<number>(mismatches.map(m => m.line));
+		const displayLines = getMismatchDisplayLines(mismatches, fileLines);
+		const width = displayLines.reduce((cur, n) => Math.max(cur, String(n).length), 0);
+
+		const out = [...HashlineMismatchError.rejectionHeader(mismatches), ""];
+		let previous = -1;
+		for (const lineNum of displayLines) {
+			if (previous !== -1 && lineNum > previous + 1) out.push("...");
+			previous = lineNum;
+			const marker = mismatchSet.has(lineNum) ? "*" : " ";
+			out.push(formatCodeFrameLine(marker, lineNum, fileLines[lineNum - 1] ?? "", width));
+		}
+		return out.join("\n");
+	}
+
+	static formatMessage(mismatches: HashMismatch[], fileLines: string[]): string {
+		const mismatchSet = new Set<number>(mismatches.map(m => m.line));
+		const lines = HashlineMismatchError.rejectionHeader(mismatches);
+		let previous = -1;
+		for (const lineNum of getMismatchDisplayLines(mismatches, fileLines)) {
+			if (previous !== -1 && lineNum > previous + 1) lines.push("...");
+			previous = lineNum;
+			const text = fileLines[lineNum - 1] ?? "";
+			const hash = computeLineHash(lineNum, text);
+			const marker = mismatchSet.has(lineNum) ? "*" : " ";
+			lines.push(`${marker}${lineNum}${hash}${HL_BODY_SEP}${text}`);
+		}
+		return lines.join("\n");
+	}
+}
+
+export function validateLineRef(ref: { line: number; hash: string }, fileLines: string[]): void {
+	if (ref.line < 1 || ref.line > fileLines.length) {
+		throw new Error(`Line ${ref.line} does not exist (file has ${fileLines.length} lines)`);
+	}
+	const actualHash = computeLineHash(ref.line, fileLines[ref.line - 1] ?? "");
+	if (actualHash !== ref.hash) {
+		throw new HashlineMismatchError([{ line: ref.line, expected: ref.hash, actual: actualHash }], fileLines);
+	}
+}