@oh-my-pi/pi-coding-agent 15.5.3 → 15.5.6

package/src/edit/normalize.ts

@@ -1,51 +1,21 @@
 /**
  * Text normalization utilities for the edit tool.
  *
- * Handles line endings, BOM, whitespace, and Unicode normalization.
+ * Whitespace, Unicode, and indentation helpers. Line-ending and BOM
+ * primitives live in `@oh-my-pi/hashline` and are re-exported here so
+ * existing consumers see one stable surface.
  */
 
 import { padding } from "@oh-my-pi/pi-tui";
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Line Ending Utilities
-// ═══════════════════════════════════════════════════════════════════════════
-
-export type LineEnding = "\r\n" | "\n";
-
-/** Detect the predominant line ending in content */
-export function detectLineEnding(content: string): LineEnding {
-	const crlfIdx = content.indexOf("\r\n");
-	const lfIdx = content.indexOf("\n");
-	if (lfIdx === -1) return "\n";
-	if (crlfIdx === -1) return "\n";
-	return crlfIdx < lfIdx ? "\r\n" : "\n";
-}
-
-/** Normalize all line endings to LF */
-export function normalizeToLF(text: string): string {
-	return text.replace(/\r\n?/g, "\n");
-}
-
-/** Restore line endings to the specified type */
-export function restoreLineEndings(text: string, ending: LineEnding): string {
-	return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// BOM Handling
-// ═══════════════════════════════════════════════════════════════════════════
-
-export interface BomResult {
-	/** The BOM character if present, empty string otherwise */
-	bom: string;
-	/** The text without the BOM */
-	text: string;
-}
-
-/** Strip UTF-8 BOM if present */
-export function stripBom(content: string): BomResult {
-	return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
-}
+export {
+	type BomResult,
+	detectLineEnding,
+	type LineEnding,
+	normalizeToLF,
+	restoreLineEndings,
+	stripBom,
+} from "@oh-my-pi/hashline";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Whitespace Utilities

package/src/edit/renderer.ts

@@ -2,11 +2,11 @@
  * Edit tool renderer and LSP batching helpers.
  */
 
+import { HL_FILE_PREFIX } from "@oh-my-pi/hashline";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { HL_FILE_PREFIX } from "../hashline/hash";
 import type { FileDiagnosticsResult } from "../lsp";
 import { renderDiff as renderDiffColored } from "../modes/components/diff";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
@@ -235,14 +235,21 @@ function renderPlainTextPreview(text: string, uiTheme: Theme, filePath?: string)
 
 function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, label = "streaming"): string {
 	if (!diff) return "";
-	const lines = diff.split("\n");
-	const total = lines.length;
-	const displayLines = lines.slice(-EDIT_STREAMING_PREVIEW_LINES);
-	const hidden = total - displayLines.length;
+	// Hunk-aware truncation keeps the change rows themselves visible and
+	// trims surrounding context proportionally so a multi-hunk diff doesn't
+	// turn into just the tail of the last hunk while streaming.
+	const {
+		text: truncatedDiff,
+		hiddenHunks,
+		hiddenLines,
+	} = truncateDiffByHunk(diff, PREVIEW_LIMITS.DIFF_COLLAPSED_HUNKS, EDIT_STREAMING_PREVIEW_LINES);
 	let text = "\n\n";
-	text += renderDiffColored(displayLines.join("\n"), { filePath: rawPath });
-	if (hidden > 0) {
-		text += uiTheme.fg("dim", `\n… (${label} +${hidden} lines)`);
+	text += renderDiffColored(truncatedDiff, { filePath: rawPath });
+	if (hiddenHunks > 0 || hiddenLines > 0) {
+		const remainder: string[] = [];
+		if (hiddenHunks > 0) remainder.push(`${hiddenHunks} more hunks`);
+		if (hiddenLines > 0) remainder.push(`${hiddenLines} more lines`);
+		text += uiTheme.fg("dim", `\n… (${label} +${remainder.join(", ")})`);
 	} else {
 		text += uiTheme.fg("dim", `\n(${label})`);
 	}

package/src/edit/streaming.ts

@@ -13,22 +13,18 @@
  * the injected `editMode` rather than probing argument shape.
  */
 
-import { sanitizeText } from "@oh-my-pi/pi-utils";
 import {
 	ABORT_MARKER,
 	BEGIN_PATCH_MARKER,
-	computeHashlineDiff,
-	computeHashlineSectionDiff,
 	containsRecognizableHashlineOperations,
 	END_PATCH_MARKER,
-	type HashlineInputSection,
-	HashlineTokenizer,
-	splitHashlineInputs,
-} from "../hashline";
+	type PatchSection as HashlineInputSection,
+	Patch as HashlinePatch,
+} from "@oh-my-pi/hashline";
 import type { Theme } from "../modes/theme/theme";
-import { replaceTabs, truncateToWidth } from "../tools/render-utils";
 import { type EditMode, resolveEditMode } from "../utils/edit-mode";
 import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
+import { computeHashlineDiff, computeHashlineSectionDiff } from "./hashline/diff";
 import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
 import { computePatchDiff, type PatchEditEntry } from "./modes/patch";
 import type { ReplaceEditEntry } from "./modes/replace";
@@ -74,48 +70,6 @@ export interface EditStreamingStrategy<Args = unknown> {
 	renderStreamingFallback(args: Args, uiTheme: Theme): string;
 }
 
-const STREAMING_FALLBACK_LINES = 12;
-const STREAMING_FALLBACK_WIDTH = 80;
-
-// Streaming-preview classification reuses one tokenizer instance for the
-// stateless predicates and `tokenize`/`tokenizeAll` helpers; instances are
-// cheap, but keeping a single module-level reference matches the rest of
-// the hashline package.
-const HASHLINE_TOKENIZER = new HashlineTokenizer();
-
-function trimHashlineStreamingSyntax(lines: string[]): string[] {
-	let index = lines.findIndex(line => line.trim().length > 0);
-	if (index === -1) return [];
-
-	if (HASHLINE_TOKENIZER.tokenize(lines[index]).kind === "envelope-begin") {
-		index++;
-		while (index < lines.length && lines[index].trim().length === 0) index++;
-	}
-	if (index < lines.length && HASHLINE_TOKENIZER.tokenize(lines[index]).kind === "header") {
-		index++;
-	}
-
-	return lines.slice(index).filter(line => !HASHLINE_TOKENIZER.isEnvelopeMarker(line));
-}
-
-function renderHashlineInputFallback(input: string, uiTheme: Theme): string {
-	const lines = trimHashlineStreamingSyntax(sanitizeText(input).split("\n"));
-	if (!lines.some(line => line.trim().length > 0)) return "";
-
-	const displayLines = lines.slice(-STREAMING_FALLBACK_LINES);
-	const hidden = lines.length - displayLines.length;
-	let text = "\n\n";
-	text += displayLines
-		.map(line => uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), STREAMING_FALLBACK_WIDTH)))
-		.join("\n");
-	if (hidden > 0) {
-		text += uiTheme.fg("dim", `\n… (streaming +${hidden} lines)`);
-	} else {
-		text += uiTheme.fg("dim", "\n(streaming)");
-	}
-	return text;
-}
-
 // -----------------------------------------------------------------------------
 // Partial-JSON handling
 // -----------------------------------------------------------------------------
@@ -274,7 +228,6 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 
 interface HashlineArgs {
 	input?: string;
-	path?: string;
 	__partialJson?: string;
 }
 
@@ -354,75 +307,6 @@ function buildApplyPatchNaturalOrderPreviews(input: string): PerFileDiffPreview[
 	return previews.length > 0 ? previews : null;
 }
 
-/**
- * Hashline equivalent: emit each payload line as a `+added` line in the
- * order the model typed it. We deliberately omit op headers and removal
- * targets from the streaming preview because their content lives in the file
- * and would require a costly re-apply per tick; the complete unified diff is
- * shown once streaming finishes.
- */
-function buildHashlineNaturalOrderPreviews(
-	input: string,
-	defaultPath: string | undefined,
-): PerFileDiffPreview[] | null {
-	const groups = new Map<string, string[]>();
-	let currentPath = defaultPath ?? "";
-	const ensure = (sectionPath: string): string[] => {
-		let bucket = groups.get(sectionPath);
-		if (!bucket) {
-			bucket = [];
-			groups.set(sectionPath, bucket);
-		}
-		return bucket;
-	};
-
-	// Per-call instance: the streaming preview re-runs each tick with the
-	// cumulative input, and we need the line counter to start at 1. A
-	// dedicated tokenizer keeps the shared HASHLINE_TOKENIZER above free
-	// for stateless predicate use elsewhere in this module.
-	const streamer = new HashlineTokenizer();
-	for (const token of streamer.tokenizeAll(input)) {
-		switch (token.kind) {
-			case "envelope-begin":
-			case "envelope-end":
-			case "abort":
-			case "op-delete":
-				continue;
-			case "blank":
-			case "raw":
-				continue;
-			case "header":
-				currentPath = token.path;
-				if (currentPath) ensure(currentPath);
-				continue;
-			case "op-insert":
-			case "op-replace":
-				// Inline body on the op line itself (`N↓payload`, `A-B:payload`) is
-				// payload content that just happens to share a line with the op
-				// header — render it the same as a standalone payload token so
-				// the very first character the model types after the sigil shows
-				// up in the streaming preview. Without this, the preview is
-				// empty until a newline arrives, and the renderer falls back to
-				// raw input ("A-B: bla bla bla") instead of "+ bla bla bla".
-				if (!currentPath || token.inlineBody === undefined) continue;
-				ensure(currentPath).push(`+${token.inlineBody}`);
-				continue;
-			case "payload":
-				if (!currentPath) continue;
-				ensure(currentPath).push(`+${token.text}`);
-				continue;
-		}
-	}
-
-	if (groups.size === 0) return null;
-	const previews: PerFileDiffPreview[] = [];
-	for (const [sectionPath, body] of groups) {
-		if (body.length === 0) continue;
-		previews.push({ path: sectionPath, diff: body.join("\n") });
-	}
-	return previews.length > 0 ? previews : null;
-}
-
 const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 	extractCompleteEdits(args) {
 		return args;
@@ -431,25 +315,21 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		if (typeof args.input !== "string" || args.input.length === 0) return null;
 		const input = trimTrailingPartialLine(args.input, ctx.isStreaming);
 		if (input.length === 0) return null;
-		if (ctx.isStreaming) {
-			// Skip the costly per-tick re-apply and avoid `Diff.structuredPatch`
-			// reordering by showing payload lines in input order.
-			return buildHashlineNaturalOrderPreviews(input, args.path);
-		}
 		ctx.signal.throwIfAborted();
 
-		let sections: HashlineInputSection[];
+		let sections: readonly HashlineInputSection[];
 		try {
-			sections = splitHashlineInputs(input, { cwd: ctx.cwd, path: args.path });
+			sections = HashlinePatch.parse(input, { cwd: ctx.cwd }).sections;
 		} catch {
-			// Single-section fallback keeps the original error rendering for the
-			// "haven't typed `¶ PATH` yet" case.
-			const result = await computeHashlineDiff({ input, path: args.path }, ctx.cwd, {
+			// While streaming, the trailing op may still be mid-typed and fail
+			// to parse; suppress until the next chunk arrives. Once args are
+			// complete, surface the error so the model sees what went wrong.
+			if (ctx.isStreaming) return null;
+			const result = await computeHashlineDiff({ input }, ctx.cwd, {
 				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
 			});
 			ctx.signal.throwIfAborted();
-			if ("error" in result && !args.path) return [{ path: "", error: result.error }];
-			return [toPerFilePreview(args.path ?? "", result)];
+			return [toPerFilePreview("", result)];
 		}
 		if (sections.length === 0) return null;
 
@@ -468,6 +348,7 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 			const section = sectionsToProcess[i];
 			const result = await computeHashlineSectionDiff(section, ctx.cwd, {
 				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
+				streaming: ctx.isStreaming,
 			});
 			ctx.signal.throwIfAborted();
 			// In a multi-section preview, ignore parse/apply errors from the
@@ -480,8 +361,13 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		}
 		return previews.length > 0 ? previews : null;
 	},
-	renderStreamingFallback(args, uiTheme) {
-		return typeof args.input === "string" ? renderHashlineInputFallback(args.input, uiTheme) : "";
+	renderStreamingFallback() {
+		// Never leak raw hashline syntax (`64:`, `|payload`, `¶path#hash`)
+		// to the user — the streaming preview already projects every
+		// parseable op onto the real file via applyPartialTo, and an
+		// unparseable trailing chunk renders as "no preview yet" rather
+		// than a sigil dump.
+		return "";
 	},
 };
 

package/src/extensibility/legacy-pi-ai-shim.ts

@@ -0,0 +1,24 @@
+/**
+ * Compatibility shim for legacy extensions importing the package root of
+ * `@oh-my-pi/pi-ai` (or one of its aliased scopes like `@earendil-works/pi-ai`
+ * or `@mariozechner/pi-ai`).
+ *
+ * pi-ai 15.1.0 removed the historical TypeBox root exports (`Type`, plus the
+ * runtime-relevant half of the `Static`/`TSchema` pair) from the package
+ * entrypoint. Legacy extensions still author parameter schemas as
+ * `Type.Object({ ... })`, so this file is served by `legacy-pi-compat.ts` in
+ * place of the real pi-ai entrypoint whenever a legacy extension imports the
+ * bare package root. Subpath imports (`@oh-my-pi/pi-ai/utils/oauth`, etc.)
+ * continue to resolve directly against the bundled pi-ai package.
+ *
+ * The `Type` runtime is borrowed from the Zod-backed TypeBox shim that
+ * already serves bare `@sinclair/typebox` imports for the same extension
+ * class, keeping the legacy-compat surface internally consistent.
+ *
+ * Type-level `Static` and `TSchema` continue to come from pi-ai's own
+ * `types.ts` via the `export *` below — pi-ai still exports both as types,
+ * only the runtime `Type` builder was removed.
+ */
+
+export * from "@oh-my-pi/pi-ai";
+export { Type } from "./typebox";

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

@@ -2,6 +2,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";
+import { isCompiledBinary } from "@oh-my-pi/pi-utils";
 
 // Canonical scope for in-process pi packages. Plugins published against any of
 // the aliased scopes below (mariozechner's original publish, earendil-works'
@@ -56,7 +57,34 @@ const resolvedSpecifierFallbacks = new Map<string, string>();
 // relying on them must vendor `@sinclair/typebox` directly.
 const TYPEBOX_SPECIFIER = "@sinclair/typebox";
 const TYPEBOX_SPECIFIER_FILTER = /^@sinclair\/typebox$/;
-const TYPEBOX_SHIM_PATH = path.resolve(import.meta.dir, "../typebox.ts");
+
+// In-process compat shim paths. In dev `import.meta.dir` is the source folder of
+// this file, so the dev branches resolve to the real `.ts` source. In compiled
+// binaries `import.meta.dir` collapses to `/$bunfs/root`, so the runtime cannot
+// recover the source layout that way; instead, each shim file is registered as
+// a `--compile` entrypoint in `scripts/build-binary.ts`, which Bun emits into
+// bunfs at a deterministic `--root`-relative path with a `.js` extension. The
+// literals below must stay in sync with that listing — if either path drifts,
+// every legacy plugin loading the shim fails with a missing-module error in
+// release builds (without affecting `bun test`/dev).
+const TYPEBOX_SHIM_PATH = isCompiledBinary()
+	? "/$bunfs/root/packages/coding-agent/src/extensibility/typebox.js"
+	: path.resolve(import.meta.dir, "../typebox.ts");
+
+// Legacy extensions historically imported `Type` (and `Static`/`TSchema`) from
+// the package root of `@(scope)/pi-ai`. pi-ai 15.1.0 removed the runtime `Type`
+// export (see `packages/ai/CHANGELOG.md`), so the bare canonical specifier no
+// longer satisfies those imports. The override below redirects only the bare
+// pi-ai package root onto a sibling shim that re-exports the canonical surface
+// plus the borrowed `Type` runtime from the Zod-backed TypeBox shim. Subpath
+// imports such as `@oh-my-pi/pi-ai/utils/oauth` continue to resolve directly
+// against the bundled pi-ai package.
+const LEGACY_PI_AI_SHIM_PATH = isCompiledBinary()
+	? "/$bunfs/root/packages/coding-agent/src/extensibility/legacy-pi-ai-shim.js"
+	: path.resolve(import.meta.dir, "../legacy-pi-ai-shim.ts");
+const LEGACY_PI_PACKAGE_ROOT_OVERRIDES: Record<string, string> = {
+	[`${CANONICAL_PI_SCOPE}/pi-ai`]: LEGACY_PI_AI_SHIM_PATH,
+};
 
 let isLegacyPiSpecifierShimInstalled = false;
 
@@ -85,6 +113,22 @@ function getResolvedSpecifier(specifier: string): string {
 	return resolved;
 }
 
+/**
+ * Resolve a canonical `@oh-my-pi/*` specifier to a filesystem path, preferring
+ * a bundled compat shim when one is registered for the package root.
+ *
+ * Falls back to `getResolvedSpecifier` (which may throw under compiled binary
+ * mode); callers handle that the same way they would for non-overridden
+ * specifiers.
+ */
+function resolveCanonicalPiSpecifier(remappedSpecifier: string): string {
+	const override = LEGACY_PI_PACKAGE_ROOT_OVERRIDES[remappedSpecifier];
+	if (override) {
+		return override;
+	}
+	return getResolvedSpecifier(remappedSpecifier);
+}
+
 function toImportSpecifier(resolvedPath: string): string {
 	return url.pathToFileURL(resolvedPath).href;
 }
@@ -99,7 +143,7 @@ function rewriteLegacyPiImports(source: string): string {
 			}
 
 			try {
-				return `${prefix}${toImportSpecifier(getResolvedSpecifier(remappedSpecifier))}${suffix}`;
+				return `${prefix}${toImportSpecifier(resolveCanonicalPiSpecifier(remappedSpecifier))}${suffix}`;
 			} catch {
 				// Resolution failed — typically in compiled binary mode where
 				// Bun.resolveSync cannot walk up from /$bunfs/root to find the
@@ -250,7 +294,7 @@ function resolveLegacyPiSpecifier(args: { path: string; importer: string }): { p
 	// Primary: resolve the canonical @oh-my-pi/* specifier from the host binary
 	// location. Works in dev mode and in source-link installs.
 	try {
-		return { path: getResolvedSpecifier(remappedSpecifier) };
+		return { path: resolveCanonicalPiSpecifier(remappedSpecifier) };
 	} catch {
 		// Fallback for compiled binary mode: the bundled packages live inside
 		// /$bunfs/root and aren't reachable by filesystem resolution. Try the

package/src/index.ts

@@ -26,7 +26,6 @@ export * from "./extensibility/extensions";
 export * from "./extensibility/skills";
 // Slash commands
 export { type FileSlashCommand, loadSlashCommands as discoverSlashCommands } from "./extensibility/slash-commands";
-export * from "./hashline";
 export type * from "./lsp";
 // Main entry point
 export * from "./main";