@oh-my-pi/pi-coding-agent 6.7.0 → 6.7.67

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [6.7.67] - 2026-01-19
+### Added
+
+- Added normative rewrite setting to control tool call argument normalization in session history
+- Added read line numbers setting to prepend line numbers to read tool output by default
+- Added streaming preview for edit and write tools with spinner animation
+- Added automatic anchor derivation for normative patches when anchors not specified
+
+### Changed
+
+- Enhanced edit and write tool renderers to show streaming content preview
+- Updated read tool to respect default line numbers setting
+- Improved normative patch anchor handling to support undefined anchors
+
 ## [6.7.0] - 2026-01-19
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "6.7.0",
+	"version": "6.7.67",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -40,10 +40,10 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-agent-core": "6.7.0",
-		"@oh-my-pi/pi-ai": "6.7.0",
-		"@oh-my-pi/pi-git-tool": "6.7.0",
-		"@oh-my-pi/pi-tui": "6.7.0",
+		"@oh-my-pi/pi-agent-core": "6.7.67",
+		"@oh-my-pi/pi-ai": "6.7.67",
+		"@oh-my-pi/pi-git-tool": "6.7.67",
+		"@oh-my-pi/pi-tui": "6.7.67",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/core/agent-session.ts

@@ -440,7 +440,7 @@ export class AgentSession {
 					details?: unknown;
 					$normative?: Record<string, unknown>;
 				};
-				if ($normative && toolCallId) {
+				if ($normative && toolCallId && this.settingsManager.getNormativeRewrite()) {
 					await this._rewriteToolCallArgs(toolCallId, $normative);
 				}
 			}

package/src/core/settings-manager.ts

@@ -236,6 +236,8 @@ export interface Settings {
 	disabledExtensions?: string[]; // Individual extension IDs that are disabled (e.g., "skill:commit")
 	statusLine?: StatusLineSettings; // Status line configuration
 	showHardwareCursor?: boolean; // Show terminal cursor while still positioning it for IME
+	normativeRewrite?: boolean; // default: false (rewrite tool call arguments to normalized format in session history)
+	readLineNumbers?: boolean; // default: false (prepend line numbers to read tool output by default)
 }
 
 export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
@@ -1299,6 +1301,24 @@ export class SettingsManager {
 		await this.save();
 	}
 
+	getNormativeRewrite(): boolean {
+		return this.settings.normativeRewrite ?? false;
+	}
+
+	async setNormativeRewrite(enabled: boolean): Promise<void> {
+		this.globalSettings.normativeRewrite = enabled;
+		await this.save();
+	}
+
+	getReadLineNumbers(): boolean {
+		return this.settings.readLineNumbers ?? false;
+	}
+
+	async setReadLineNumbers(enabled: boolean): Promise<void> {
+		this.globalSettings.readLineNumbers = enabled;
+		await this.save();
+	}
+
 	getDisabledProviders(): string[] {
 		return [...(this.settings.disabledProviders ?? [])];
 	}

package/src/core/tools/index.ts

@@ -125,6 +125,7 @@ export interface ToolSession {
 	/** Settings manager (optional) */
 	settings?: {
 		getImageAutoResize(): boolean;
+		getReadLineNumbers?(): boolean;
 		getLspFormatOnWrite(): boolean;
 		getLspDiagnosticsOnWrite(): boolean;
 		getLspDiagnosticsOnEdit(): boolean;

package/src/core/tools/patch/normative.ts

@@ -4,6 +4,7 @@
 
 import { generateUnifiedDiffString } from "./diff";
 import { normalizeToLF, stripBom } from "./normalize";
+import { parseHunks } from "./parser";
 import type { PatchInput } from "./types";
 
 export interface NormativePatchOptions {
@@ -17,7 +18,7 @@ export interface NormativePatchOptions {
 
 /** Normative patch input is the MongoDB-style update variant */
 
-function applyAnchors(diff: string, anchors: string[] | undefined): string {
+function applyAnchors(diff: string, anchors: Array<string | undefined> | undefined): string {
 	if (!anchors || anchors.length === 0) {
 		return diff;
 	}
@@ -28,17 +29,40 @@ function applyAnchors(diff: string, anchors: string[] | undefined): string {
 		const anchor = anchors[anchorIndex];
 		if (anchor !== undefined) {
 			lines[i] = anchor.trim().length === 0 ? "@@" : `@@ ${anchor}`;
-			anchorIndex++;
 		}
+		anchorIndex++;
 	}
 	return lines.join("\n");
 }
 
+function deriveAnchors(diff: string): Array<string | undefined> {
+	const hunks = parseHunks(diff);
+	return hunks.map((hunk) => {
+		if (hunk.oldLines.length === 0 || hunk.newLines.length === 0) {
+			return undefined;
+		}
+		const newLines = new Set(hunk.newLines);
+		for (const line of hunk.oldLines) {
+			const trimmed = line.trim();
+			if (trimmed.length === 0) continue;
+			if (!/[A-Za-z0-9_]/.test(trimmed)) continue;
+			if (newLines.has(line)) {
+				return trimmed;
+			}
+		}
+		return undefined;
+	});
+}
+
 export function buildNormativeUpdateInput(options: NormativePatchOptions): PatchInput {
 	const normalizedOld = normalizeToLF(stripBom(options.oldContent).text);
 	const normalizedNew = normalizeToLF(stripBom(options.newContent).text);
 	const diffResult = generateUnifiedDiffString(normalizedOld, normalizedNew, options.contextLines ?? 3);
-	const anchors = typeof options.anchor === "string" ? [options.anchor] : options.anchor;
+	let anchors: Array<string | undefined> | undefined =
+		typeof options.anchor === "string" ? [options.anchor] : options.anchor;
+	if (!anchors) {
+		anchors = deriveAnchors(diffResult.diff);
+	}
 	const diff = applyAnchors(diffResult.diff, anchors);
 	return {
 		path: options.path,

package/src/core/tools/patch/shared.ts

@@ -5,17 +5,20 @@
 import type { ToolCallContext } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
+import { renderDiff as renderDiffColored } from "../../../modes/interactive/components/diff";
 import { getLanguageFromPath, type Theme } from "../../../modes/interactive/theme/theme";
 import type { RenderResultOptions } from "../../custom-tools/types";
 import type { FileDiagnosticsResult } from "../lsp/index";
 import {
 	createToolUIKit,
 	formatExpandHint,
+	formatStatusIcon,
 	getDiffStats,
 	shortenPath,
 	type ToolUIKit,
 	truncateDiffByHunk,
 } from "../render-utils";
+import type { RenderCallOptions } from "../renderers";
 import type { DiffError, DiffResult, Operation } from "./types";
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -82,12 +85,29 @@ export interface EditRenderContext {
 
 const EDIT_DIFF_PREVIEW_HUNKS = 2;
 const EDIT_DIFF_PREVIEW_LINES = 24;
+const EDIT_STREAMING_PREVIEW_LINES = 12;
 
 function countLines(text: string): number {
 	if (!text) return 0;
 	return text.split("\n").length;
 }
 
+function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme): 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;
+
+	let text = "\n\n";
+	if (hidden > 0) {
+		text += uiTheme.fg("dim", `${uiTheme.format.ellipsis} (${hidden} earlier lines)\n`);
+	}
+	text += renderDiffColored(displayLines.join("\n"), { filePath: rawPath });
+	text += uiTheme.fg("dim", `\n${uiTheme.format.ellipsis} (streaming)`);
+	return text;
+}
+
 function formatMetadataLine(lineCount: number | null, language: string | undefined, uiTheme: Theme): string {
 	const icon = uiTheme.getLangIcon(language);
 	if (lineCount !== null) {
@@ -136,7 +156,7 @@ function renderDiffSection(
 export const editToolRenderer = {
 	mergeCallAndResult: true,
 
-	renderCall(args: EditRenderArgs, uiTheme: Theme): Component {
+	renderCall(args: EditRenderArgs, uiTheme: Theme, options?: RenderCallOptions): Component {
 		const ui = createToolUIKit(uiTheme);
 		const rawPath = args.file_path || args.path || "";
 		const filePath = shortenPath(rawPath);
@@ -151,7 +171,16 @@ export const editToolRenderer = {
 
 		// Show operation type for patch mode
 		const opTitle = args.op === "create" ? "Create" : args.op === "delete" ? "Delete" : "Edit";
-		const text = `${ui.title(opTitle)} ${editIcon} ${pathDisplay}`;
+		const spinner =
+			options?.spinnerFrame !== undefined ? formatStatusIcon("running", uiTheme, options.spinnerFrame) : "";
+		let text = `${ui.title(opTitle)} ${spinner ? `${spinner} ` : ""}${editIcon} ${pathDisplay}`;
+
+		// Show streaming preview of diff/content
+		const streamingContent = args.diff ?? args.newText ?? args.patch;
+		if (streamingContent) {
+			text += formatStreamingDiff(streamingContent, rawPath, uiTheme);
+		}
+
 		return new Text(text, 0, 0);
 	},
 

package/src/core/tools/read.ts

@@ -441,11 +441,13 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 	private readonly session: ToolSession;
 	private readonly autoResizeImages: boolean;
+	private readonly defaultLineNumbers: boolean;
 	private readonly lsTool: LsTool;
 
 	constructor(session: ToolSession) {
 		this.session = session;
 		this.autoResizeImages = session.settings?.getImageAutoResize() ?? true;
+		this.defaultLineNumbers = session.settings?.getReadLineNumbers?.() ?? false;
 		this.lsTool = new LsTool(session);
 		this.description = renderPromptTemplate(readDescription, {
 			DEFAULT_MAX_LINES: String(DEFAULT_MAX_LINES),
@@ -622,8 +624,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				// Apply truncation (respects both line and byte limits)
 				const truncation = truncateHead(selectedContent);
 
-				// Add line numbers if requested (default: false)
-				const shouldAddLineNumbers = lines === true;
+				// Add line numbers if requested (uses setting default if not specified)
+				const shouldAddLineNumbers = lines ?? this.defaultLineNumbers;
 				const prependLineNumbers = (text: string, startNum: number): string => {
 					const textLines = text.split("\n");
 					const lastLineNum = startNum + textLines.length - 1;

package/src/core/tools/renderers.ts

@@ -26,8 +26,12 @@ import { webFetchToolRenderer } from "./web-fetch";
 import { webSearchToolRenderer } from "./web-search/render";
 import { writeToolRenderer } from "./write";
 
+export interface RenderCallOptions {
+	spinnerFrame?: number;
+}
+
 type ToolRenderer = {
-	renderCall: (args: unknown, theme: Theme) => Component;
+	renderCall: (args: unknown, theme: Theme, options?: RenderCallOptions) => Component;
 	renderResult: (
 		result: { content: Array<{ type: string; text?: string }>; details?: unknown; isError?: boolean },
 		options: RenderResultOptions & { renderContext?: Record<string, unknown> },

package/src/core/tools/write.ts

@@ -21,7 +21,8 @@ import {
 	writethroughNoop,
 } from "./lsp/index";
 import { resolveToCwd } from "./path-utils";
-import { formatDiagnostics, formatExpandHint, replaceTabs, shortenPath } from "./render-utils";
+import { formatDiagnostics, formatExpandHint, formatStatusIcon, replaceTabs, shortenPath } from "./render-utils";
+import type { RenderCallOptions } from "./renderers";
 
 const writeSchema = Type.Object({
 	path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
@@ -124,11 +125,34 @@ interface WriteRenderArgs {
 	content?: string;
 }
 
+const WRITE_STREAMING_PREVIEW_LINES = 12;
+
 function countLines(text: string): number {
 	if (!text) return 0;
 	return text.split("\n").length;
 }
 
+function formatStreamingContent(content: string, rawPath: string, uiTheme: Theme): string {
+	if (!content) return "";
+	const lang = getLanguageFromPath(rawPath);
+	const lines = content.split("\n");
+	const total = lines.length;
+	const displayLines = lines.slice(-WRITE_STREAMING_PREVIEW_LINES);
+	const hidden = total - displayLines.length;
+
+	const formattedLines = lang
+		? highlightCode(replaceTabs(displayLines.join("\n")), lang)
+		: displayLines.map((line: string) => uiTheme.fg("toolOutput", replaceTabs(line)));
+
+	let text = "\n\n";
+	if (hidden > 0) {
+		text += uiTheme.fg("dim", `${uiTheme.format.ellipsis} (${hidden} earlier lines)\n`);
+	}
+	text += formattedLines.join("\n");
+	text += uiTheme.fg("dim", `\n${uiTheme.format.ellipsis} (streaming)`);
+	return text;
+}
+
 function formatMetadataLine(lineCount: number | null, language: string | undefined, uiTheme: Theme): string {
 	const icon = uiTheme.getLangIcon(language);
 	if (lineCount !== null) {
@@ -138,11 +162,19 @@ function formatMetadataLine(lineCount: number | null, language: string | undefin
 }
 
 export const writeToolRenderer = {
-	renderCall(args: WriteRenderArgs, uiTheme: Theme): Component {
+	renderCall(args: WriteRenderArgs, uiTheme: Theme, options?: RenderCallOptions): Component {
 		const rawPath = args.file_path || args.path || "";
 		const filePath = shortenPath(rawPath);
 		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", uiTheme.format.ellipsis);
-		const text = `${uiTheme.fg("toolTitle", uiTheme.bold("Write"))} ${pathDisplay}`;
+		const spinner =
+			options?.spinnerFrame !== undefined ? formatStatusIcon("running", uiTheme, options.spinnerFrame) : "";
+		let text = `${uiTheme.fg("toolTitle", uiTheme.bold("Write"))} ${spinner ? `${spinner} ` : ""}${pathDisplay}`;
+
+		// Show streaming preview of content
+		if (args.content) {
+			text += formatStreamingContent(args.content, rawPath, uiTheme);
+		}
+
 		return new Text(text, 0, 0);
 	},
 

package/src/modes/interactive/components/settings-defs.ts

@@ -209,6 +209,15 @@ export const SETTINGS_DEFS: SettingDef[] = [
 		get: (sm) => sm.getCollapseChangelog(),
 		set: (sm, v) => sm.setCollapseChangelog(v),
 	},
+	{
+		id: "normativeRewrite",
+		tab: "behavior",
+		type: "boolean",
+		label: "Normative rewrite",
+		description: "Rewrite tool call arguments to normalized format in session history",
+		get: (sm) => sm.getNormativeRewrite(),
+		set: (sm, v) => sm.setNormativeRewrite(v),
+	},
 	{
 		id: "doubleEscapeAction",
 		tab: "behavior",
@@ -312,6 +321,15 @@ export const SETTINGS_DEFS: SettingDef[] = [
 		get: (sm) => sm.getEditPatchMode(),
 		set: (sm, v) => sm.setEditPatchMode(v),
 	},
+	{
+		id: "readLineNumbers",
+		tab: "tools",
+		type: "boolean",
+		label: "Read line numbers",
+		description: "Prepend line numbers to read tool output by default",
+		get: (sm) => sm.getReadLineNumbers(),
+		set: (sm, v) => sm.setReadLineNumbers(v),
+	},
 	{
 		id: "mcpProjectConfig",
 		tab: "tools",

package/src/modes/interactive/components/tool-execution.ts

@@ -135,6 +135,8 @@ export class ToolExecutionComponent extends Container {
 	// Spinner animation for partial task results
 	private spinnerFrame = 0;
 	private spinnerInterval: ReturnType<typeof setInterval> | null = null;
+	// Track if args are still being streamed (for edit/write spinner)
+	private argsComplete = false;
 
 	constructor(
 		toolName: string,
@@ -175,6 +177,7 @@ export class ToolExecutionComponent extends Container {
 
 	updateArgs(args: any, _toolCallId?: string): void {
 		this.args = args;
+		this.updateSpinnerAnimation();
 		this.updateDisplay();
 	}
 
@@ -183,6 +186,8 @@ export class ToolExecutionComponent extends Container {
 	 * This triggers diff computation for edit tool.
 	 */
 	setArgsComplete(_toolCallId?: string): void {
+		this.argsComplete = true;
+		this.updateSpinnerAnimation();
 		this.maybeComputeEditDiff();
 	}
 
@@ -311,7 +316,10 @@ export class ToolExecutionComponent extends Container {
 	 * Start or stop spinner animation based on whether this is a partial task result.
 	 */
 	private updateSpinnerAnimation(): void {
-		const needsSpinner = this.isPartial && this.toolName === "task";
+		// Spinner for: task tool with partial result, or edit/write while args streaming
+		const isStreamingArgs = !this.argsComplete && (this.toolName === "edit" || this.toolName === "write");
+		const isPartialTask = this.isPartial && this.toolName === "task";
+		const needsSpinner = isStreamingArgs || isPartialTask;
 		if (needsSpinner && !this.spinnerInterval) {
 			this.spinnerInterval = setInterval(() => {
 				const frameCount = theme.spinnerFrames.length;
@@ -428,7 +436,9 @@ export class ToolExecutionComponent extends Container {
 			if (shouldRenderCall) {
 				// Render call component
 				try {
-					const callComponent = renderer.renderCall(this.args, theme);
+					const callComponent = renderer.renderCall(this.args, theme, {
+						spinnerFrame: this.spinnerFrame,
+					});
 					if (callComponent) {
 						// Ensure component has invalidate() method for Component interface
 						const component = callComponent as any;