@oh-my-pi/pi-coding-agent 14.5.1 → 14.5.3

package/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 ## [Unreleased]
 
+## [14.5.3] - 2026-04-27
+
+### Added
+
+- Added bracketed `loc` forms `(anchor)`, `[anchor]`, `[anchor`, `(anchor`, `anchor]`, and `anchor)` to `atom` `splice` editing so a single anchor can target a block body, whole node, or partial node region
+- Added automatic block-delimiter inference for block splices using file extension, defaulting to `{` and using `(` for Lisp-family files
+- Added optional `pre`/`post` arguments to the `href` prompt helper so hashline references can be wrapped as bracketed or parenthesized anchors
+- Added destination-aware indent handling for block replacements by detecting file indent style and reapplying tabs/spaces to spliced body text
+
+### Changed
+
+- Changed bracketed atom locators to be `splice`-only and reject `pre`, `post`, or `sed` on region locators
+- Changed `applyAtomEdits` to forbid mixing `splice_block` with other anchor-scoped edit verbs in one call
+- Changed `splice_block` resolution behavior to include selected block range and enclosing-count context in warning output
+- Changed balanced-block parsing to support `kind` selection (`{`, `(`, `[`), nesting depth, and safer same-line enclosing selection
+
+### Removed
+
+- Removed the `sed` `F` option for literal matching; `sed` now accepts only `pat`, `rep`, and optional `g`, with `F`-style literal matching no longer supported
+
+### Fixed
+
+- Fixed `splice_block` multi-line replacements to replace the exact target region and avoid duplicate braces or duplicated signature lines from bare-anchor `splice` attempts
+- Fixed false-positive “unbalanced” replacement-body warnings caused by braces in regex/string/comment text by skipping those constructs during block scanning
+- Fixed `splice_block` for same-line `(` bodies so inline call sites like `int(port)` can be replaced correctly
+
+## [14.5.2] - 2026-04-26
+### Breaking Changes
+
+- Removed support for sed-style string expressions and required `sed` to be specified as an object with `pat` and `rep` (and optional `g`, `F`, `i` flags)
+
+### Changed
+
+- Changed atom `sed` replacements to be global by default and require `g:false` for first-match-only replacements
+- Changed anchor validation so multiple `sed` operations can target the same line and run sequentially
+- Changed cross-entry conflict resolution so `del` edits on an anchor are ignored when that line is also replaced by `sed` or `splice` in another edit entry
+
+### Fixed
+
+- Fixed zero-length regex `sed` patterns (for example `()`, `^`, `$`) to fall back to literal substring matching instead of producing insertion-like replacements
+- Fixed `sed` chaining so each edit on the same anchor applies to the latest line state from prior replacements
+
 ## [14.5.1] - 2026-04-26
 
 ### Removed
@@ -762,6 +804,7 @@
 - Fixed PR checkout tool to resolve symlinks in worktree paths, ensuring consistent path references in results and metadata
 - Fixed `read` output for file-backed internal URLs like `local://...` to include hashline prefixes in hashline edit mode, preserving usable line refs for follow-up edits
 - Fixed the plan review selector to support the external editor shortcut for opening and updating the current plan from the approval screen
+- Fixed status line dropping git branch name when path is long by shrinking the path segment before dropping other segments
 
 ## [13.18.0] - 2026-04-02
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.5.1",
+	"version": "14.5.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.20.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.5.1",
-		"@oh-my-pi/pi-agent-core": "14.5.1",
-		"@oh-my-pi/pi-ai": "14.5.1",
-		"@oh-my-pi/pi-natives": "14.5.1",
-		"@oh-my-pi/pi-tui": "14.5.1",
-		"@oh-my-pi/pi-utils": "14.5.1",
+		"@oh-my-pi/omp-stats": "14.5.3",
+		"@oh-my-pi/pi-agent-core": "14.5.3",
+		"@oh-my-pi/pi-ai": "14.5.3",
+		"@oh-my-pi/pi-natives": "14.5.3",
+		"@oh-my-pi/pi-tui": "14.5.3",
+		"@oh-my-pi/pi-utils": "14.5.3",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@xterm/headless": "^6.0.0",
@@ -69,7 +69,7 @@
 		"zod": "4.3.6"
 	},
 	"devDependencies": {
-		"@types/bun": "^1.3.13",
+		"@types/bun": "^1.3",
 		"@types/turndown": "5.0.6"
 	},
 	"engines": {

package/src/config/prompt-templates.ts

@@ -45,11 +45,14 @@ function formatHashlineRef(lineNum: unknown, content: unknown): { num: number; t
 
 /**
  * {{href lineNum "content"}} — compute a real hashline ref for prompt examples.
- * Returns `"lineNumBIGRAM"` (e.g., `"42nd"`) using the actual hash algorithm.
+ * {{href lineNum "content" "[" "]"}} — wrap the ref with pre/post chars (still quoted).
+ * Returns `"lineNumBIGRAM"` (e.g., `"42nd"`), or `"[42nd]"` when pre/post are supplied.
  */
-prompt.registerHelper("href", (lineNum: unknown, content: unknown): string => {
+prompt.registerHelper("href", (lineNum: unknown, content: unknown, pre?: unknown, post?: unknown): string => {
 	const { ref } = formatHashlineRef(lineNum, content);
-	return JSON.stringify(ref);
+	const preStr = typeof pre === "string" ? pre : "";
+	const postStr = typeof post === "string" ? post : "";
+	return JSON.stringify(`${preStr}${ref}${postStr}`);
 });
 
 /**

package/src/edit/block.ts

@@ -0,0 +1,308 @@
+/**
+ * Block-balanced delimiter finder used by the `splice_block` verb.
+ *
+ * Tokenizes source text to skip strings and comments, then walks a stack of
+ * open delimiters to identify the enclosing balanced block for a target line.
+ *
+ * This is intentionally language-agnostic over the C-family (C, C++, Rust,
+ * Go, Java, JS/TS, C#, Swift, Kotlin, Scala, …): it understands `// line`,
+ * `/* block * /` comments, double-quoted, single-quoted, and backtick strings
+ * with backslash escapes. It does NOT attempt to parse raw string literals,
+ * Python triple-quoted strings, or YAML/Python indent-significant blocks —
+ * those are out of scope for v1.
+ */
+
+export type DelimiterKind = "{" | "(" | "[";
+
+export interface BlockRange {
+	/** Byte/character offset of the opening delimiter. */
+	openOffset: number;
+	/** Byte/character offset just after the closing delimiter. */
+	closeOffsetExclusive: number;
+	/** Offset of first character after the opener (start of body). */
+	bodyStart: number;
+	/** Offset of the closing delimiter character. */
+	bodyEnd: number;
+	/** 1-indexed line number of the opener. */
+	openLine: number;
+	/** Byte/character offset of the opener line start. */
+	openLineStart: number;
+	/** 1-indexed line number of the closer. */
+	closeLine: number;
+	/** True when opener and closer are on the same line. */
+	sameLine: boolean;
+	/** Whitespace prefix of the opener's line. */
+	openerLineIndent: string;
+	/**
+	 * Whitespace prefix of the first non-blank body line, or `null` when the
+	 * body has no non-blank line.
+	 */
+	bodyLineIndent: string | null;
+	/** Body text exactly as it appears between the delimiters. */
+	bodyText: string;
+	/** Total enclosing blocks of the requested kind before depth selection. */
+	enclosingCount: number;
+}
+
+interface BraceEvent {
+	kind: DelimiterKind | ")" | "]" | "}";
+	offset: number;
+}
+
+const OPENERS: Record<DelimiterKind, string> = { "{": "{", "(": "(", "[": "[" };
+const CLOSERS: Record<DelimiterKind, string> = { "{": "}", "(": ")", "[": "]" };
+
+/**
+ * Walk `text` and emit positions of opening and closing delimiters that lie
+ * outside strings and comments.
+ */
+export function scanDelimiters(text: string): BraceEvent[] {
+	const out: BraceEvent[] = [];
+	const len = text.length;
+	let i = 0;
+	while (i < len) {
+		const ch = text[i]!;
+		// Line comment `// …` to end of line.
+		if (ch === "/" && text[i + 1] === "/") {
+			i += 2;
+			while (i < len && text[i] !== "\n") i++;
+			continue;
+		}
+		// Hash line comment `# …` for shell/Python-like — but only when at start
+		// of a token, to avoid mangling C preprocessor lines (`#include`). We
+		// treat any `#` at column 0 or after whitespace as a line comment, which
+		// is a heuristic that's also fine for `#include` (no braces follow on
+		// the same line in practice for our use case).
+		if (ch === "#" && (i === 0 || text[i - 1] === "\n" || text[i - 1] === " " || text[i - 1] === "\t")) {
+			// Not enabled: too aggressive for C/C++/Rust files. Skip.
+		}
+		// Block comment `/* … */`.
+		if (ch === "/" && text[i + 1] === "*") {
+			i += 2;
+			while (i < len && !(text[i] === "*" && text[i + 1] === "/")) i++;
+			if (i < len) i += 2;
+			continue;
+		}
+		// String literals: ", ', `. Backslash-escape aware.
+		if (ch === '"' || ch === "'" || ch === "`") {
+			const quote = ch;
+			i++;
+			while (i < len) {
+				const c = text[i]!;
+				if (c === "\\") {
+					i += 2;
+					continue;
+				}
+				if (c === quote) {
+					i++;
+					break;
+				}
+				if (c === "\n" && (quote === '"' || quote === "'")) {
+					// Unterminated string; stop scanning this literal so we
+					// don't swallow the rest of the file.
+					break;
+				}
+				i++;
+			}
+			continue;
+		}
+		if (ch === "{" || ch === "(" || ch === "[") {
+			out.push({ kind: ch, offset: i });
+		} else if (ch === "}" || ch === ")" || ch === "]") {
+			out.push({ kind: ch, offset: i });
+		}
+		i++;
+	}
+	return out;
+}
+
+interface OpenFrame {
+	kind: DelimiterKind;
+	offset: number;
+}
+
+/**
+ * Build a list of balanced (open, close) ranges by walking the events from
+ * `scanDelimiters`. Mismatched closers are skipped (the file may be partially
+ * malformed), and unclosed openers at EOF are dropped.
+ */
+function pairBlocks(events: BraceEvent[]): { open: OpenFrame; closeOffset: number }[] {
+	const stack: OpenFrame[] = [];
+	const pairs: { open: OpenFrame; closeOffset: number }[] = [];
+	for (const ev of events) {
+		if (ev.kind === "{" || ev.kind === "(" || ev.kind === "[") {
+			stack.push({ kind: ev.kind, offset: ev.offset });
+			continue;
+		}
+		// Closer.
+		const expected: DelimiterKind | null =
+			ev.kind === "}" ? "{" : ev.kind === ")" ? "(" : ev.kind === "]" ? "[" : null;
+		if (!expected) continue;
+		// Pop until we find the matching opener, but only commit pairs when
+		// kinds match. This tolerates small skews from raw strings or other
+		// unsupported constructs without exploding the search.
+		const top = stack[stack.length - 1];
+		if (top?.kind === expected) {
+			stack.pop();
+			pairs.push({ open: top, closeOffset: ev.offset });
+		}
+	}
+	return pairs;
+}
+
+function lineToOffset(text: string, line: number): number {
+	let n = 1;
+	let i = 0;
+	while (i < text.length && n < line) {
+		if (text[i] === "\n") n++;
+		i++;
+	}
+	return i;
+}
+
+function offsetToLine(text: string, offset: number): number {
+	let n = 1;
+	for (let i = 0; i < offset && i < text.length; i++) {
+		if (text[i] === "\n") n++;
+	}
+	return n;
+}
+
+function lineIndentAt(text: string, lineNumber: number): string {
+	const start = lineToOffset(text, lineNumber);
+	let i = start;
+	while (i < text.length && (text[i] === " " || text[i] === "\t")) i++;
+	return text.slice(start, i);
+}
+
+function extractRange(text: string, start: number, end: number): string {
+	return text.slice(start, end);
+}
+
+export interface FindBlockOptions {
+	kind?: DelimiterKind;
+	depth?: number;
+}
+
+export interface FindBlockError {
+	message: string;
+}
+
+/**
+ * Find the enclosing balanced block of `kind` containing `targetLine`
+ * (1-indexed), at the requested ancestor `depth` (0 = innermost).
+ *
+ * Returns an error object when no such block exists.
+ */
+export function findEnclosingBlock(
+	text: string,
+	targetLine: number,
+	options: FindBlockOptions = {},
+): BlockRange | FindBlockError {
+	const kind: DelimiterKind = options.kind ?? "{";
+	const depth = Math.max(0, Math.floor(options.depth ?? 0));
+
+	const events = scanDelimiters(text);
+	const pairs = pairBlocks(events);
+
+	// Lines (1-indexed) that bracket the target are considered to contain it.
+	// This handles same-line `{ x }` blocks too (openLine == closeLine ==
+	// targetLine).
+	const enclosing = pairs
+		.filter(p => p.open.kind === kind)
+		.map(p => ({
+			open: p.open,
+			closeOffset: p.closeOffset,
+			openLine: offsetToLine(text, p.open.offset),
+			closeLine: offsetToLine(text, p.closeOffset),
+		}))
+		.filter(p => p.openLine <= targetLine && targetLine <= p.closeLine);
+	if (enclosing.length === 0) {
+		return {
+			message: `No enclosing \`${kind}\` block contains line ${targetLine}.`,
+		};
+	}
+	// Default ordering is innermost first (largest open offset among containers).
+	// When both candidates are entirely on the target line, prefer the outermost
+	// same-line block so anchoring a call line targets the containing call before
+	// nested argument calls such as `int(port)`. Multi-line nesting keeps the
+	// existing innermost-first behavior.
+	enclosing.sort((a, b) => {
+		const aSingle = a.openLine === targetLine && a.closeLine === targetLine;
+		const bSingle = b.openLine === targetLine && b.closeLine === targetLine;
+		if (aSingle && bSingle) return a.open.offset - b.open.offset;
+		return b.open.offset - a.open.offset;
+	});
+	if (depth >= enclosing.length) {
+		return {
+			message: `Requested depth ${depth} exceeds available enclosing \`${kind}\` blocks (${enclosing.length}).`,
+		};
+	}
+	const chosen = enclosing[depth]!;
+	const openOffset = chosen.open.offset;
+	const closeOffset = chosen.closeOffset;
+	const bodyStart = openOffset + 1;
+	const bodyEnd = closeOffset;
+	const openLine = chosen.openLine;
+	const closeLine = chosen.closeLine;
+	const openLineStart = lineToOffset(text, openLine);
+	const openerLineIndent = lineIndentAt(text, openLine);
+	const bodyText = extractRange(text, bodyStart, bodyEnd);
+	const bodyLineIndent = computeBodyLineIndent(text, bodyStart, bodyEnd);
+	return {
+		openOffset,
+		closeOffsetExclusive: closeOffset + 1,
+		bodyStart,
+		bodyEnd,
+		openLine,
+		openLineStart,
+		closeLine,
+		sameLine: openLine === closeLine,
+		openerLineIndent,
+		bodyLineIndent,
+		bodyText,
+		enclosingCount: enclosing.length,
+	};
+}
+
+function computeBodyLineIndent(text: string, bodyStart: number, bodyEnd: number): string | null {
+	// Scan body for the first line whose non-whitespace character lives within
+	// [bodyStart, bodyEnd). Return that line's leading whitespace prefix.
+	let i = bodyStart;
+	// Step over the rest of the opener's line (it may contain trailing
+	// whitespace but not body content we want to use as the indent reference).
+	while (i < bodyEnd && text[i] !== "\n") i++;
+	while (i < bodyEnd) {
+		// At line boundary; skip the newline.
+		if (text[i] === "\n") i++;
+		const lineStart = i;
+		while (i < bodyEnd && (text[i] === " " || text[i] === "\t")) i++;
+		// Skip blank lines.
+		if (i < bodyEnd && text[i] !== "\n") {
+			return text.slice(lineStart, i);
+		}
+		// Skip to end of line.
+		while (i < bodyEnd && text[i] !== "\n") i++;
+	}
+	return null;
+}
+
+/**
+ * Verify that the agent's body has balanced delimiters of `kind`. Returns an
+ * error message when unbalanced, or `null` when fine.
+ */
+export function checkBodyBraceBalance(body: string, kind: DelimiterKind): string | null {
+	const events = scanDelimiters(body);
+	let opens = 0;
+	let closes = 0;
+	const opener = OPENERS[kind];
+	const closer = CLOSERS[kind];
+	for (const e of events) {
+		if (e.kind === opener) opens++;
+		else if (e.kind === closer) closes++;
+	}
+	if (opens !== closes) {
+		return `Replacement body has unbalanced \`${opener}\`/\`${closer}\` (open=${opens}, close=${closes}).`;
+	}
+	return null;
+}

package/src/edit/indent.ts

@@ -0,0 +1,150 @@
+/**
+ * Indent helpers used by `splice_block`.
+ *
+ * Pure functions: take strings/lines, return strings/lines. No I/O. Designed
+ * to be easy to unit-test in isolation.
+ */
+
+export interface IndentStyle {
+	kind: "tab" | "space";
+	width: number;
+}
+
+const SAMPLE_LINES_FOR_DETECTION = 256;
+
+/**
+ * Detect whether the file uses tab or space indentation, and the indent width
+ * for spaces. Sampling-based; defaults to {kind: "tab", width: 1} when nothing
+ * is conclusive.
+ */
+export function detectIndentStyle(text: string): IndentStyle {
+	const lines = text.split("\n", SAMPLE_LINES_FOR_DETECTION + 1).slice(0, SAMPLE_LINES_FOR_DETECTION);
+	let tabIndented = 0;
+	let spaceIndented = 0;
+	const spaceWidthCounts = new Map<number, number>();
+	for (const line of lines) {
+		if (line.length === 0) continue;
+		const ch0 = line[0];
+		if (ch0 === "\t") {
+			tabIndented++;
+			continue;
+		}
+		if (ch0 !== " ") continue;
+		let count = 0;
+		while (count < line.length && line[count] === " ") count++;
+		// Skip lines whose entire content is whitespace (no signal).
+		if (count === line.length) continue;
+		spaceIndented++;
+		// Record indent step. Try common values 2, 4, 8 by GCD-ish.
+		spaceWidthCounts.set(count, (spaceWidthCounts.get(count) ?? 0) + 1);
+	}
+	if (tabIndented > spaceIndented) return { kind: "tab", width: 1 };
+	if (spaceIndented === 0) return { kind: "tab", width: 1 };
+
+	// Pick the most common nonzero indent width that divides the others well.
+	const candidates = [2, 4, 8];
+	let bestCandidate = 4;
+	let bestScore = -1;
+	for (const cand of candidates) {
+		let score = 0;
+		for (const [width, count] of spaceWidthCounts) {
+			if (width % cand === 0) score += count;
+		}
+		if (score > bestScore) {
+			bestScore = score;
+			bestCandidate = cand;
+		}
+	}
+	return { kind: "space", width: bestCandidate };
+}
+
+/**
+ * Strip the common leading whitespace prefix from every non-empty line.
+ * Blank/whitespace-only lines pass through unchanged.
+ *
+ * Tab and space whitespace count as a single character each here; we look at
+ * raw prefix bytes. The block executor re-applies destination indent later,
+ * so tab/space mismatches in the agent's own input are normalized by
+ * `applyIndent` rather than here.
+ */
+export function stripCommonIndent(lines: readonly string[]): string[] {
+	let common: string | null = null;
+	for (const line of lines) {
+		if (line.trim().length === 0) continue;
+		const m = /^[\t ]*/.exec(line);
+		const prefix = m ? m[0] : "";
+		if (common === null) {
+			common = prefix;
+			continue;
+		}
+		// Reduce to the longest shared prefix.
+		let i = 0;
+		const limit = Math.min(common.length, prefix.length);
+		while (i < limit && common[i] === prefix[i]) i++;
+		common = common.slice(0, i);
+		if (common.length === 0) break;
+	}
+	if (!common) return [...lines];
+	return lines.map(line => (line.startsWith(common!) ? line.slice(common!.length) : line));
+}
+
+/**
+ * Re-index leading whitespace of `lines` from the source style to the
+ * destination style, then prepend `prefix` to every non-empty line.
+ *
+ * - Source style is detected from the lines themselves.
+ * - Tab→space and space→tab conversion is applied to the *relative*
+ *   indentation (everything past the common prefix has already been stripped
+ *   by `stripCommonIndent`, so all leading whitespace here is "extra" indent).
+ * - Blank lines stay empty (no trailing whitespace).
+ */
+export function applyIndent(lines: readonly string[], prefix: string, destStyle: IndentStyle): string[] {
+	const sourceStyle = detectIndentStyle(lines.join("\n"));
+	return lines.map(line => {
+		if (line.trim().length === 0) return "";
+		const m = /^[\t ]*/.exec(line);
+		const leading = m ? m[0] : "";
+		const rest = line.slice(leading.length);
+		const normalized = normalizeIndent(leading, sourceStyle, destStyle);
+		return prefix + normalized + rest;
+	});
+}
+
+function normalizeIndent(leading: string, source: IndentStyle, dest: IndentStyle): string {
+	if (leading.length === 0) return leading;
+	// Compute total visual columns of the leading run, treating tabs in the
+	// source as `source.width` columns (or 1 column for tab-indented files,
+	// where the destination decides the visible width).
+	let columns = 0;
+	for (const ch of leading) {
+		if (ch === "\t") {
+			// Treat a source tab as one indent unit. Width = source.width or
+			// fallback 4 when source is tab style.
+			columns += source.kind === "tab" ? 1 : Math.max(1, Math.floor(source.width));
+		} else {
+			columns += 1;
+		}
+	}
+	if (dest.kind === "tab") {
+		// Convert visual columns to whole tabs. When source was space-indented,
+		// columns is in spaces; divide by source.width to get logical levels.
+		let levels: number;
+		if (source.kind === "tab") {
+			levels = columns;
+		} else {
+			const w = Math.max(1, source.width);
+			levels = Math.round(columns / w);
+		}
+		return "\t".repeat(Math.max(0, levels));
+	}
+	// Destination is spaces. Convert to dest.width columns per level.
+	let levels: number;
+	if (source.kind === "tab") {
+		levels = columns; // tabs were 1 column each here
+	} else {
+		const w = Math.max(1, source.width);
+		levels = Math.round(columns / w);
+	}
+	const out = " ".repeat(Math.max(0, levels) * Math.max(1, dest.width));
+	return out;
+}