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

package/src/debug/raw-sse.ts

@@ -0,0 +1,213 @@
+import { sanitizeText } from "@oh-my-pi/pi-natives";
+import { type Component, matchesKey, padding, replaceTabs, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
+import { theme } from "../modes/theme/theme";
+import { copyToClipboard } from "../utils/clipboard";
+import { formatRawSseIsoTime, type RawSseDebugBuffer, rawSseRecordLines } from "./raw-sse-buffer";
+
+const MIN_VIEWER_WIDTH = 20;
+const VIEWER_FRAME_LINES = 5;
+
+function sanitizeFrameLine(line: string, width: number): string {
+	return truncateToWidth(replaceTabs(sanitizeText(line)), width);
+}
+
+export interface RawSseViewerOptions {
+	buffer: RawSseDebugBuffer;
+	terminalRows: number;
+	onExit: () => void;
+	onStatus?: (message: string) => void;
+	onUpdate?: () => void;
+}
+
+export class RawSseViewerComponent implements Component {
+	readonly #buffer: RawSseDebugBuffer;
+	readonly #terminalRows: number;
+	readonly #onExit: () => void;
+	readonly #onStatus?: (message: string) => void;
+	readonly #onUpdate?: () => void;
+	readonly #unsubscribe: () => void;
+	#scrollOffset = 0;
+	#followTail = true;
+	#lastRenderWidth = MIN_VIEWER_WIDTH;
+	#statusMessage: string | undefined;
+
+	constructor(options: RawSseViewerOptions) {
+		this.#buffer = options.buffer;
+		this.#terminalRows = options.terminalRows;
+		this.#onExit = options.onExit;
+		this.#onStatus = options.onStatus;
+		this.#onUpdate = options.onUpdate;
+		this.#unsubscribe = this.#buffer.subscribe(() => {
+			this.#followIfNeeded();
+			this.#onUpdate?.();
+		});
+	}
+
+	handleInput(keyData: string): void {
+		if (matchesKey(keyData, "escape") || matchesKey(keyData, "esc")) {
+			this.#unsubscribe();
+			this.#onExit();
+			return;
+		}
+
+		if (matchesKey(keyData, "ctrl+c")) {
+			this.#copyAll();
+			return;
+		}
+
+		if (matchesKey(keyData, "up")) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.max(0, this.#scrollOffset - 1);
+			this.#onUpdate?.();
+			return;
+		}
+
+		if (matchesKey(keyData, "down")) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.min(this.#maxScrollOffset(), this.#scrollOffset + 1);
+			this.#onUpdate?.();
+			return;
+		}
+
+		if (matchesKey(keyData, "pageUp")) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.max(0, this.#scrollOffset - this.#bodyHeight());
+			this.#onUpdate?.();
+			return;
+		}
+
+		if (matchesKey(keyData, "pageDown")) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.min(this.#maxScrollOffset(), this.#scrollOffset + this.#bodyHeight());
+			this.#onUpdate?.();
+			return;
+		}
+
+		if (matchesKey(keyData, "end")) {
+			this.#followTail = true;
+			this.#scrollToTail();
+			this.#onUpdate?.();
+		}
+	}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		this.#lastRenderWidth = Math.max(MIN_VIEWER_WIDTH, width);
+		this.#followIfNeeded();
+
+		const innerWidth = Math.max(1, this.#lastRenderWidth - 2);
+		const bodyHeight = this.#bodyHeight();
+		const rawLines = this.#renderRawLines(innerWidth);
+		const body = rawLines.slice(this.#scrollOffset, this.#scrollOffset + bodyHeight);
+		while (body.length < bodyHeight) body.push("");
+
+		return [
+			this.#frameTop(innerWidth),
+			this.#frameLine(this.#summaryText(), innerWidth),
+			this.#frameSeparator(innerWidth),
+			...body.map(line => this.#frameLine(line, innerWidth)),
+			this.#frameLine(this.#statusText(), innerWidth),
+			this.#frameBottom(innerWidth),
+		];
+	}
+
+	#renderRawLines(innerWidth: number): string[] {
+		const snapshot = this.#buffer.snapshot();
+		if (snapshot.records.length === 0) {
+			return [
+				theme.fg("muted", "No raw SSE frames captured yet."),
+				theme.fg("muted", "HTTP SSE providers populate this view while a model response is streaming."),
+			];
+		}
+
+		const lines: string[] = [];
+		if (snapshot.droppedRecords > 0) {
+			lines.push(
+				theme.fg(
+					"warning",
+					`: omp-debug-dropped records=${snapshot.droppedRecords} chars=${snapshot.droppedChars}`,
+				),
+			);
+			lines.push("");
+		}
+		for (const record of snapshot.records) {
+			for (const line of rawSseRecordLines(record)) {
+				lines.push(sanitizeFrameLine(line, innerWidth));
+			}
+			if (record.kind === "event" && record.truncated) {
+				lines.push(theme.fg("warning", `: omp-debug-event-truncated originalChars=${record.originalChars}`));
+			}
+			lines.push("");
+		}
+		return lines;
+	}
+
+	#summaryText(): string {
+		const snapshot = this.#buffer.snapshot();
+		const last = snapshot.lastUpdatedAt ? ` last=${formatRawSseIsoTime(snapshot.lastUpdatedAt)}` : "";
+		const follow = this.#followTail ? "follow:on" : "follow:off";
+		return ` # raw SSE | events=${snapshot.totalEvents} records=${snapshot.records.length}${last} | ${follow} | Esc back Ctrl+C copy End follow`;
+	}
+
+	#statusText(): string {
+		return this.#statusMessage ?? " Up/Down scroll  PgUp/PgDn page";
+	}
+
+	#bodyHeight(): number {
+		return Math.max(3, this.#terminalRows - VIEWER_FRAME_LINES);
+	}
+
+	#followIfNeeded(): void {
+		if (this.#followTail) this.#scrollToTail();
+	}
+
+	#scrollToTail(): void {
+		this.#scrollOffset = this.#maxScrollOffset();
+	}
+
+	#maxScrollOffset(): number {
+		const innerWidth = Math.max(1, this.#lastRenderWidth - 2);
+		return Math.max(0, this.#renderRawLines(innerWidth).length - this.#bodyHeight());
+	}
+
+	#copyAll(): void {
+		const payload = this.#buffer.toRawText();
+		if (payload.trim().length === 0) {
+			const message = "No raw SSE frames to copy";
+			this.#statusMessage = message;
+			this.#onStatus?.(message);
+			this.#onUpdate?.();
+			return;
+		}
+
+		try {
+			copyToClipboard(payload);
+			const message = "Copied raw SSE stream";
+			this.#statusMessage = message;
+			this.#onStatus?.(message);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.#statusMessage = `Copy failed: ${message}`;
+		}
+		this.#onUpdate?.();
+	}
+
+	#frameTop(innerWidth: number): string {
+		return `${theme.boxSharp.topLeft}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.topRight}`;
+	}
+
+	#frameSeparator(innerWidth: number): string {
+		return `${theme.boxSharp.teeRight}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.teeLeft}`;
+	}
+
+	#frameBottom(innerWidth: number): string {
+		return `${theme.boxSharp.bottomLeft}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.bottomRight}`;
+	}
+
+	#frameLine(content: string, innerWidth: number): string {
+		const truncated = truncateToWidth(content, innerWidth);
+		const remaining = Math.max(0, innerWidth - visibleWidth(truncated));
+		return `${theme.boxSharp.vertical}${truncated}${padding(remaining)}${theme.boxSharp.vertical}`;
+	}
+}

package/src/edit/index.ts

@@ -1,6 +1,14 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { prompt } from "@oh-my-pi/pi-utils";
 import type { Static } from "@sinclair/typebox";
+import {
+	executeHashlineSingle,
+	HashlineMismatchError,
+	type HashlineParams,
+	hashlineEditParamsSchema,
+} from "../hashline";
+import hashlineGrammarTemplate from "../hashline/grammar.lark" with { type: "text" };
+import { resolveHashlineGrammarPlaceholders } from "../hashline/hash";
 import {
 	createLspWritethrough,
 	type FileDiagnosticsResult,
@@ -16,16 +24,8 @@ import type { ToolSession } from "../tools";
 import { VimTool, vimSchema } from "../tools/vim";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
 import type { VimToolDetails } from "../vim/types";
-import { resolveHashlineGrammarPlaceholders } from "./line-hash";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
-import {
-	executeHashlineSingle,
-	HashlineMismatchError,
-	type HashlineParams,
-	hashlineEditParamsSchema,
-} from "./modes/hashline";
-import hashlineGrammarTemplate from "./modes/hashline.lark" with { type: "text" };
 import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
 import { executeReplaceSingle, type ReplaceEditEntry, type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
@@ -34,13 +34,12 @@ export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/ed
 export * from "./apply-patch";
 export * from "./diff";
 export * from "./file-read-cache";
-export * from "./line-hash";
 
 // Resolve the `$HFMT$` and `$HSEP$` placeholders in the hashline Lark grammar.
 const hashlineGrammar = resolveHashlineGrammarPlaceholders(hashlineGrammarTemplate);
 
+export * from "../hashline";
 export * from "./modes/apply-patch";
-export * from "./modes/hashline";
 export * from "./modes/patch";
 export * from "./modes/replace";
 export * from "./normalize";

package/src/edit/streaming.ts

@@ -12,17 +12,18 @@
  * The shared renderer / `ToolExecutionComponent` consult the strategy via
  * the injected `editMode` rather than probing argument shape.
  */
-import type { Theme } from "../modes/theme/theme";
-import { type EditMode, resolveEditMode } from "../utils/edit-mode";
-import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
-import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
+
 import {
 	computeHashlineDiff,
 	computeHashlineSectionDiff,
 	containsRecognizableHashlineOperations,
 	type HashlineInputSection,
 	splitHashlineInputs,
-} from "./modes/hashline";
+} from "../hashline";
+import type { Theme } from "../modes/theme/theme";
+import { type EditMode, resolveEditMode } from "../utils/edit-mode";
+import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
+import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
 import { computePatchDiff, type PatchEditEntry } from "./modes/patch";
 import type { ReplaceEditEntry } from "./modes/replace";
 

package/src/eval/js/context-manager.ts

@@ -5,6 +5,7 @@ import { pathToFileURL } from "node:url";
 import * as util from "node:util";
 import * as vm from "node:vm";
 
+import { parse as babelParse } from "@babel/parser";
 import * as Diff from "diff";
 import type { ToolSession } from "../../tools";
 import { ToolError } from "../../tools/tool-errors";
@@ -488,65 +489,108 @@ function buildRequire(cwd: string): NodeJS.Require {
 	return createRequire(pathToFileURL(path.join(cwd, "[eval]")).href);
 }
 
-// Static `import ... from "x"` is not valid inside vm.runInContext. Rewrite the common
-// forms to dynamic `await import(...)` so users can paste ESM-style imports verbatim.
-const STATIC_IMPORT_RE = /^[ \t]*import\b(?:[ \t]+([^'"\n]+?)[ \t]+from)?[ \t]*(['"])([^'"\n]+)\2[ \t]*;?[ \t]*$/gm;
-
-function splitTopLevel(clause: string): string[] {
-	const out: string[] = [];
-	let depth = 0;
-	let buf = "";
-	for (const ch of clause) {
-		if (ch === "{") depth++;
-		else if (ch === "}") depth--;
-		if (ch === "," && depth === 0) {
-			if (buf.trim()) out.push(buf.trim());
-			buf = "";
-		} else {
-			buf += ch;
-		}
-	}
-	if (buf.trim()) out.push(buf.trim());
-	return out;
+// Static `import ... from "x"` is not valid inside vm.runInContext (script-mode parsing).
+// Rewrite top-level static imports to dynamic `await import(...)` so users can paste ESM
+// source verbatim. We use a real parser instead of regex matching so imports embedded in
+// string literals, template literals, or comments — common in codemods — stay intact.
+
+type BabelImportDeclaration = {
+	type: "ImportDeclaration";
+	start: number;
+	end: number;
+	source: { value: string };
+	specifiers: ReadonlyArray<{
+		type: "ImportDefaultSpecifier" | "ImportNamespaceSpecifier" | "ImportSpecifier";
+		local: { name: string };
+		imported?: { type: "Identifier"; name: string } | { type: "StringLiteral"; value: string };
+	}>;
+	attributes?: ReadonlyArray<{
+		key: { type: "Identifier"; name: string } | { type: "StringLiteral"; value: string };
+		value: { value: string };
+	}>;
+};
+
+function buildDynamicImportCall(sourceLiteral: string, withClause: string | undefined): string {
+	return withClause ? `import(${sourceLiteral}, { with: ${withClause} })` : `import(${sourceLiteral})`;
 }
 
-function rewriteImportClause(clause: string, sourceLiteral: string): string {
+function buildWithClause(node: BabelImportDeclaration): string | undefined {
+	const attrs = node.attributes;
+	if (!attrs || attrs.length === 0) return undefined;
+	const pairs = attrs.map(attr => {
+		const key = attr.key.type === "Identifier" ? attr.key.name : JSON.stringify(attr.key.value);
+		return `${key}: ${JSON.stringify(attr.value.value)}`;
+	});
+	return `{ ${pairs.join(", ")} }`;
+}
+
+function rewriteImportNode(node: BabelImportDeclaration): string {
+	const sourceLiteral = JSON.stringify(node.source.value);
+	const withClause = buildWithClause(node);
+	const importCall = buildDynamicImportCall(sourceLiteral, withClause);
+
 	let defaultName: string | undefined;
 	let namespaceName: string | undefined;
-	let namedBlock: string | undefined;
-	for (const part of splitTopLevel(clause)) {
-		if (part.startsWith("{")) {
-			namedBlock = part;
-		} else if (part.startsWith("*")) {
-			const m = part.match(/^\*\s+as\s+([A-Za-z_$][\w$]*)$/);
-			if (!m) return `await import(${sourceLiteral}); /* unrewritten import: ${clause} */`;
-			namespaceName = m[1];
-		} else if (/^[A-Za-z_$][\w$]*$/.test(part)) {
-			defaultName = part;
-		} else {
-			return `await import(${sourceLiteral}); /* unrewritten import: ${clause} */`;
+	const namedPairs: Array<[string, string]> = [];
+	for (const spec of node.specifiers) {
+		if (spec.type === "ImportDefaultSpecifier") {
+			defaultName = spec.local.name;
+		} else if (spec.type === "ImportNamespaceSpecifier") {
+			namespaceName = spec.local.name;
+		} else if (spec.type === "ImportSpecifier" && spec.imported) {
+			const imported = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+			namedPairs.push([imported, spec.local.name]);
 		}
 	}
-	if (namedBlock) {
-		const inner = namedBlock.slice(1, -1).trim();
-		const renamed = inner.replace(/([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)/g, "$1: $2");
-		const props = defaultName ? `default: ${defaultName}, ${renamed}` : renamed;
-		return `const { ${props} } = await import(${sourceLiteral});`;
+
+	if (namedPairs.length > 0) {
+		const inner = namedPairs.map(([imp, loc]) => (imp === loc ? imp : `${imp}: ${loc}`)).join(", ");
+		const props = defaultName ? `default: ${defaultName}, ${inner}` : inner;
+		return `const { ${props} } = await ${importCall};`;
 	}
 	if (namespaceName && defaultName) {
-		return `const ${namespaceName} = await import(${sourceLiteral}); const ${defaultName} = ${namespaceName}.default;`;
+		return `const ${namespaceName} = await ${importCall}; const ${defaultName} = ${namespaceName}.default;`;
 	}
-	if (namespaceName) return `const ${namespaceName} = await import(${sourceLiteral});`;
-	if (defaultName) return `const ${defaultName} = (await import(${sourceLiteral})).default;`;
-	return `await import(${sourceLiteral});`;
+	if (namespaceName) return `const ${namespaceName} = await ${importCall};`;
+	if (defaultName) return `const ${defaultName} = (await ${importCall}).default;`;
+	return `await ${importCall};`;
 }
 
 export function rewriteStaticImports(code: string): string {
-	return code.replace(STATIC_IMPORT_RE, (_match, clause: string | undefined, _quote, source: string) => {
-		const literal = JSON.stringify(source);
-		if (!clause) return `await import(${literal});`;
-		return rewriteImportClause(clause.trim(), literal);
-	});
+	if (!code.includes("import")) return code;
+
+	let ast: { program: { body: ReadonlyArray<{ type: string }> } };
+	try {
+		ast = babelParse(code, {
+			sourceType: "module",
+			allowAwaitOutsideFunction: true,
+			allowReturnOutsideFunction: true,
+			allowImportExportEverywhere: true,
+			allowNewTargetOutsideFunction: true,
+			allowSuperOutsideMethod: true,
+			allowUndeclaredExports: true,
+			errorRecovery: true,
+		}) as unknown as typeof ast;
+	} catch {
+		// Parser bailed entirely — let the VM surface the real syntax error.
+		return code;
+	}
+
+	// Only rewrite top-level imports. Anything nested deeper is invalid JS anyway and the
+	// VM will report it.
+	const imports: BabelImportDeclaration[] = [];
+	for (const node of ast.program.body) {
+		if (node.type === "ImportDeclaration") imports.push(node as unknown as BabelImportDeclaration);
+	}
+	if (imports.length === 0) return code;
+
+	// Splice from the back so earlier offsets stay valid.
+	imports.sort((a, b) => b.start - a.start);
+	let result = code;
+	for (const node of imports) {
+		result = result.slice(0, node.start) + rewriteImportNode(node) + result.slice(node.end);
+	}
+	return result;
 }
 
 function wrapCode(code: string): { source: string; asyncWrapped: boolean } {

package/src/extensibility/extensions/loader.ts

@@ -17,7 +17,7 @@ import type { ExecOptions } from "../../exec/exec";
 import { execCommand } from "../../exec/exec";
 import type { CustomMessage } from "../../session/messages";
 import { EventBus } from "../../utils/event-bus";
-import { installLegacyPiSpecifierShim } from "../plugins/legacy-pi-compat";
+import { installLegacyPiSpecifierShim, loadLegacyPiModule } from "../plugins/legacy-pi-compat";
 import { getAllPluginExtensionPaths } from "../plugins/loader";
 
 import { resolvePath } from "../utils";
@@ -36,6 +36,12 @@ import type {
 installLegacyPiSpecifierShim();
 
 type HandlerFn = (...args: unknown[]) => Promise<unknown>;
+type LoadedExtensionModule = ExtensionFactory | { default?: ExtensionFactory };
+
+function getExtensionFactory(module: LoadedExtensionModule): ExtensionFactory | null {
+	const candidate = typeof module === "function" ? module : module.default;
+	return typeof candidate === "function" ? candidate : null;
+}
 
 export class ExtensionRuntimeNotInitializedError extends Error {
 	constructor() {
@@ -272,8 +278,8 @@ async function loadExtension(
 ): Promise<{ extension: Extension | null; error: string | null }> {
 	const resolvedPath = resolvePath(extensionPath, cwd);
 	try {
-		const module = await import(`omp-legacy-pi-file:${resolvedPath}`);
-		const factory = (module.default ?? module) as ExtensionFactory;
+		const module = (await loadLegacyPiModule(resolvedPath)) as LoadedExtensionModule;
+		const factory = getExtensionFactory(module);
 
 		if (typeof factory !== "function") {
 			return {

package/src/extensibility/extensions/types.ts

@@ -22,7 +22,7 @@ import type {
 } from "@oh-my-pi/pi-ai";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
 import type * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
-import type { AutocompleteItem, Component, EditorComponent, EditorTheme, KeyId, TUI } from "@oh-my-pi/pi-tui";
+import type { AutocompleteItem, Component, EditorTheme, KeyId, TUI } from "@oh-my-pi/pi-tui";
 import type { Static, TSchema } from "@sinclair/typebox";
 import type { Rule } from "../../capability/rule";
 import type { KeybindingsManager } from "../../config/keybindings";
@@ -31,6 +31,7 @@ import type { EditToolDetails } from "../../edit";
 import type { PythonResult } from "../../eval/py/executor";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
+import type { CustomEditor } from "../../modes/components/custom-editor";
 import type { Theme } from "../../modes/theme/theme";
 import type { CompactionPreparation, CompactionResult } from "../../session/compaction";
 import type { CustomMessage } from "../../session/messages";
@@ -170,9 +171,15 @@ export interface ExtensionUIContext {
 		editorOptions?: { promptStyle?: boolean },
 	): Promise<string | undefined>;
 
-	/** Set a custom editor component via factory function, or undefined to restore the default editor. */
+	/**
+	 * Set a custom editor component via factory function, or `undefined` to restore the default editor.
+	 *
+	 * The factory must return a {@link CustomEditor} subclass. Plain `EditorComponent`/`Editor`
+	 * instances do not implement the action-keys, escape callbacks, and custom-key-handler surface
+	 * required by interactive mode.
+	 */
 	setEditorComponent(
-		factory: ((tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) => EditorComponent) | undefined,
+		factory: ((tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) => CustomEditor) | undefined,
 	): void;
 
 	/** Get the current theme for styling. */