@oh-my-pi/pi-coding-agent 14.9.2 → 14.9.3

package/src/tools/path-utils.ts

@@ -6,6 +6,8 @@ import { isEnoent } from "@oh-my-pi/pi-utils";
 
 const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
 const FILE_LINE_RANGE_RE = /^(?:L?\d+(?:[-+]L?\d+)?|raw)$/i;
+const FILE_LINE_RANGE_ONLY_RE = /^L?\d+(?:[-+]L?\d+)?$/i;
+const FILE_RAW_ONLY_RE = /^raw$/i;
 const NARROW_NO_BREAK_SPACE = "\u202F";
 const TOP_LEVEL_INTERNAL_URL_PREFIXES = [
 	"agent://",
@@ -110,7 +112,25 @@ export function splitPathAndSel(rawPath: string): { path: string; sel?: string }
 	const candidate = rawPath.slice(colon + 1);
 	if (!FILE_LINE_RANGE_RE.test(candidate)) return { path: rawPath };
 
-	return { path: rawPath.slice(0, colon), sel: candidate };
+	let basePath = rawPath.slice(0, colon);
+	let sel = candidate;
+
+	// Allow a compound trailing selector: `path:1-50:raw` or `path:raw:1-50`.
+	// The two chunks must be one line-range plus one `raw`, in either order.
+	const innerColon = basePath.lastIndexOf(":");
+	if (innerColon > 0) {
+		const innerCandidate = basePath.slice(innerColon + 1);
+		const innerIsRaw = FILE_RAW_ONLY_RE.test(innerCandidate);
+		const outerIsRaw = FILE_RAW_ONLY_RE.test(candidate);
+		const innerIsRange = FILE_LINE_RANGE_ONLY_RE.test(innerCandidate);
+		const outerIsRange = FILE_LINE_RANGE_ONLY_RE.test(candidate);
+		if ((innerIsRaw && outerIsRange) || (innerIsRange && outerIsRaw)) {
+			sel = `${innerCandidate}:${candidate}`;
+			basePath = basePath.slice(0, innerColon);
+		}
+	}
+
+	return { path: basePath, sel };
 }
 
 function assertNotInternalUrl(expanded: string, original: string): void {

package/src/tools/read.ts

@@ -462,34 +462,67 @@ type ReadParams = ReadToolInput;
 type ParsedSelector =
 	| { kind: "none" }
 	| { kind: "raw" }
-	| { kind: "lines"; startLine: number; endLine: number | undefined };
+	| { kind: "lines"; startLine: number; endLine: number | undefined; raw?: boolean };
 
 const LINE_RANGE_RE = /^L?(\d+)(?:([-+])L?(\d+))?$/i;
 
-function parseSel(sel: string | undefined): ParsedSelector {
-	if (!sel || sel.length === 0) return { kind: "none" };
-	if (sel.toLowerCase() === "raw") return { kind: "raw" };
+/** Returns true when the selector requested verbatim/raw output (alone or combined with a range). */
+function isRawSelector(parsed: ParsedSelector): boolean {
+	return parsed.kind === "raw" || (parsed.kind === "lines" && parsed.raw === true);
+}
+
+function parseLineRangeChunk(sel: string): { startLine: number; endLine: number | undefined } | null {
 	const lineMatch = LINE_RANGE_RE.exec(sel);
-	if (lineMatch) {
-		const rawStart = Number.parseInt(lineMatch[1]!, 10);
-		if (rawStart < 1) {
-			throw new ToolError("Line selector 0 is invalid; lines are 1-indexed. Use :1.");
+	if (!lineMatch) return null;
+	const rawStart = Number.parseInt(lineMatch[1]!, 10);
+	if (rawStart < 1) {
+		throw new ToolError("Line selector 0 is invalid; lines are 1-indexed. Use :1.");
+	}
+	const sep = lineMatch[2];
+	const rhs = lineMatch[3] ? Number.parseInt(lineMatch[3], 10) : undefined;
+	let rawEnd: number | undefined;
+	if (sep === "+") {
+		if (rhs === undefined || rhs < 1) {
+			throw new ToolError(`Invalid range ${rawStart}+${rhs ?? 0}: count must be >= 1.`);
 		}
-		const sep = lineMatch[2];
-		const rhs = lineMatch[3] ? Number.parseInt(lineMatch[3], 10) : undefined;
-		let rawEnd: number | undefined;
-		if (sep === "+") {
-			if (rhs === undefined || rhs < 1) {
-				throw new ToolError(`Invalid range ${rawStart}+${rhs ?? 0}: count must be >= 1.`);
-			}
-			rawEnd = rawStart + rhs - 1;
-		} else if (sep === "-") {
-			if (rhs === undefined || rhs < rawStart) {
-				throw new ToolError(`Invalid range ${rawStart}-${rhs ?? 0}: end must be >= start.`);
+		rawEnd = rawStart + rhs - 1;
+	} else if (sep === "-") {
+		if (rhs === undefined || rhs < rawStart) {
+			throw new ToolError(`Invalid range ${rawStart}-${rhs ?? 0}: end must be >= start.`);
+		}
+		rawEnd = rhs;
+	}
+	return { startLine: rawStart, endLine: rawEnd };
+}
+
+function parseSel(sel: string | undefined): ParsedSelector {
+	if (!sel || sel.length === 0) return { kind: "none" };
+
+	// Compound selector: `1-50:raw` or `raw:1-50`. Split into chunks and accept
+	// any combination of one line range and the literal `raw`.
+	if (sel.includes(":")) {
+		const chunks = sel.split(":");
+		if (chunks.length === 2) {
+			const [a, b] = chunks as [string, string];
+			const aIsRaw = a.toLowerCase() === "raw";
+			const bIsRaw = b.toLowerCase() === "raw";
+			const rangeChunk = aIsRaw ? b : bIsRaw ? a : null;
+			const rawChunk = aIsRaw ? a : bIsRaw ? b : null;
+			if (rangeChunk !== null && rawChunk !== null) {
+				const range = parseLineRangeChunk(rangeChunk);
+				if (range) {
+					return { kind: "lines", startLine: range.startLine, endLine: range.endLine, raw: true };
+				}
 			}
-			rawEnd = rhs;
 		}
-		return { kind: "lines", startLine: rawStart, endLine: rawEnd };
+		// Unrecognized compound — fall through (sqlite/archive/url consume their own colon syntax).
+		return { kind: "none" };
+	}
+
+	if (sel.toLowerCase() === "raw") return { kind: "raw" };
+	const range = parseLineRangeChunk(sel);
+	if (range) {
+		return { kind: "lines", startLine: range.startLine, endLine: range.endLine };
 	}
 	// Unrecognized selectors fall through; sqlite/archive/url readers consume their own colon syntax.
 	return { kind: "none" };
@@ -653,9 +686,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			entityLabel: string;
 			ignoreResultLimits?: boolean;
 			raw?: boolean;
+			immutable?: boolean;
 		},
 	): AgentToolResult<ReadToolDetails> {
-		const displayMode = resolveFileDisplayMode(this.session, { raw: options.raw });
+		const displayMode = resolveFileDisplayMode(this.session, { raw: options.raw, immutable: options.immutable });
 		const details = options.details ?? {};
 		const allLines = text.split("\n");
 		const totalLines = allLines.length;
@@ -1139,6 +1173,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					details: { ...cached.details },
 					sourceUrl: cached.details.finalUrl,
 					entityLabel: "URL output",
+					immutable: true,
 				});
 			}
 			return executeReadUrl(this.session, { path: parsedUrlTarget.path, raw: parsedUrlTarget.raw }, signal);
@@ -1150,7 +1185,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		if (internalRouter?.canHandle(internalTarget.path)) {
 			const parsed = parseSel(internalTarget.sel);
 			const { offset, limit } = selToOffsetLimit(parsed);
-			return this.#handleInternalUrl(internalTarget.path, offset, limit);
+			return this.#handleInternalUrl(internalTarget.path, offset, limit, { raw: isRawSelector(parsed) });
 		}
 
 		const archivePath = await this.#resolveArchiveReadPath(readPath, signal);
@@ -1164,7 +1199,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				limit,
 				{ ...archivePath, archiveSubPath: archiveSubPath.path },
 				signal,
-				{ raw: archiveParsed.kind === "raw" },
+				{ raw: isRawSelector(archiveParsed) },
 			);
 		}
 
@@ -1293,7 +1328,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					throw error;
 				}
 			}
-		} else if (isNotebookPath(absolutePath) && parsed.kind !== "raw") {
+		} else if (isNotebookPath(absolutePath) && !isRawSelector(parsed)) {
 			const { offset, limit } = selToOffsetLimit(parsed);
 			return this.#buildInMemoryTextResult(
 				await readEditableNotebookText(absolutePath, localReadPath),
@@ -1421,7 +1456,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					getFileReadCache(this.session).recordContiguous(absolutePath, startLineDisplay, collectedLines);
 				}
 
-				const isRawMode = parsed.kind === "raw";
+				const isRawMode = isRawSelector(parsed);
 				const shouldAddHashLines = !isRawMode && displayMode.hashLines;
 				const shouldAddLineNumbers = isRawMode ? false : shouldAddHashLines ? false : displayMode.lineNumbers;
 				let capturedDisplayContent: { text: string; startLine: number } | undefined;
@@ -1510,7 +1545,12 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	 * Handle internal URLs (agent://, artifact://, memory://, skill://, rule://, local://, mcp://).
 	 * Supports pagination via offset/limit but rejects them when query extraction is used.
 	 */
-	async #handleInternalUrl(url: string, offset?: number, limit?: number): Promise<AgentToolResult<ReadToolDetails>> {
+	async #handleInternalUrl(
+		url: string,
+		offset?: number,
+		limit?: number,
+		options?: { raw?: boolean },
+	): Promise<AgentToolResult<ReadToolDetails>> {
 		const internalRouter = this.session.internalRouter!;
 
 		// Check if URL has query extraction (agent:// only).
@@ -1550,6 +1590,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			sourceInternal: url,
 			entityLabel: "resource",
 			ignoreResultLimits: scheme === "skill",
+			immutable: resource.immutable,
+			raw: options?.raw,
 		});
 	}
 

package/src/tools/search.ts

@@ -121,7 +121,6 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			const patternHasNewline = normalizedPattern.includes("\n") || normalizedPattern.includes("\\n");
 			const effectiveMultiline = patternHasNewline;
 
-			const useHashLines = resolveFileDisplayMode(this.session).hashLines;
 			const formatScopePath = (targetPath: string): string => formatPathRelativeToCwd(targetPath, this.session.cwd);
 			let searchPath: string;
 			let scopePath: string;
@@ -134,6 +133,10 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			}
 			const internalRouter = this.session.internalRouter;
 			const resolvedPathInputs: string[] = [];
+			// Absolute filesystem paths whose source is immutable (e.g. artifact://,
+			// pi://, skill://). Hashline anchors are suppressed for these on a
+			// per-file basis, leaving editable mixed-in files untouched.
+			const immutableSourcePaths = new Set<string>();
 			for (const rawPath of rawPaths) {
 				if (!internalRouter?.canHandle(rawPath)) {
 					resolvedPathInputs.push(rawPath);
@@ -146,8 +149,13 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				if (!resource.sourcePath) {
 					throw new ToolError(`Cannot search internal URL without a backing file: ${rawPath}`);
 				}
+				if (resource.immutable) {
+					immutableSourcePaths.add(path.resolve(resource.sourcePath));
+				}
 				resolvedPathInputs.push(resource.sourcePath);
 			}
+			const baseDisplayMode = resolveFileDisplayMode(this.session);
+			const immutableDisplayMode = resolveFileDisplayMode(this.session, { immutable: true });
 			// Tolerate missing entries in a multi-path call: skip ones whose base
 			// directory is gone, and only error if every entry is missing. Single
 			// missing path keeps the original ENOENT semantics.
@@ -336,6 +344,10 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				const modelOut: string[] = [];
 				const displayOut: string[] = [];
 				const fileMatches = matchesByFile.get(relativePath) ?? [];
+				const absoluteFilePath = path.resolve(this.session.cwd, relativePath);
+				const useHashLines = immutableSourcePaths.has(absoluteFilePath)
+					? immutableDisplayMode.hashLines
+					: baseDisplayMode.hashLines;
 				const lineNumberWidth = fileMatches.reduce((width, match) => {
 					let nextWidth = Math.max(width, String(match.lineNumber).length);
 					for (const ctx of match.contextBefore ?? []) {

package/src/utils/file-display-mode.ts

@@ -21,17 +21,23 @@ export interface FileDisplayModeSession {
 /**
  * Computes effective line display mode from session settings/env.
  * Hashline mode takes precedence and implies line-addressed output everywhere.
- * Hashlines are suppressed when the edit tool is not available (e.g. explore agents)
- * and when the caller signals a `raw` read — raw output should be returned as-is
- * without injecting hashline anchors or line numbers.
+ * Hashlines are suppressed when the edit tool is not available (e.g. explore agents),
+ * when the caller signals a `raw` read, and when the source is `immutable`
+ * (e.g. internal URLs like artifact://, agent://, memory:// — there is no edit
+ * path that could consume the anchors). Raw output is returned as-is.
  */
-export function resolveFileDisplayMode(session: FileDisplayModeSession, options?: { raw?: boolean }): FileDisplayMode {
+export function resolveFileDisplayMode(
+	session: FileDisplayModeSession,
+	options?: { raw?: boolean; immutable?: boolean },
+): FileDisplayMode {
 	const { settings } = session;
 	const hasEditTool = session.hasEditTool ?? true;
 	const editMode = resolveEditMode(session);
 	const usesHashLineAnchors = editMode === "hashline";
 	const raw = options?.raw === true;
-	const hashLines = !raw && hasEditTool && usesHashLineAnchors && settings.get("readHashLines") !== false;
+	const immutable = options?.immutable === true;
+	const hashLines =
+		!raw && !immutable && hasEditTool && usesHashLineAnchors && settings.get("readHashLines") !== false;
 	return {
 		hashLines,
 		lineNumbers: !raw && (hashLines || settings.get("readLineNumbers") === true),

package/src/task/template.ts

@@ -1,47 +0,0 @@
-import { prompt } from "@oh-my-pi/pi-utils";
-import subagentUserPromptTemplate from "../prompts/system/subagent-user-prompt.md" with { type: "text" };
-import { getTaskSimpleModeCapabilities, type TaskSimpleMode } from "./simple-mode";
-import type { TaskItem } from "./types";
-
-interface RenderResult {
-	/** Full task text sent to the subagent */
-	task: string;
-	/** Raw per-task assignment text, without prompt template boilerplate */
-	assignment: string;
-	id: string;
-	description: string;
-}
-
-/**
- * Build the full task text from shared context and per-task assignment.
- *
- * If context is provided, it is prepended with a separator.
- */
-export function renderTemplate(
-	context: string | undefined,
-	task: TaskItem,
-	simpleMode: TaskSimpleMode = "default",
-): RenderResult {
-	let { id, description, assignment } = task;
-	assignment = assignment.trim();
-	const { contextEnabled } = getTaskSimpleModeCapabilities(simpleMode);
-	context = contextEnabled ? context?.trim() : undefined;
-
-	if (!context || !assignment) {
-		if (simpleMode === "independent" && assignment) {
-			return {
-				task: prompt.render(subagentUserPromptTemplate, { assignment, independentMode: true }),
-				assignment,
-				id,
-				description,
-			};
-		}
-		return { task: assignment || context!, assignment: assignment || context!, id, description };
-	}
-	return {
-		task: prompt.render(subagentUserPromptTemplate, { context, assignment, independentMode: false }),
-		assignment,
-		id,
-		description,
-	};
-}

package/src/tools/bash-normalize.ts

@@ -1,107 +0,0 @@
-/**
- * Bash command normalizer - extracts patterns that are better handled natively.
- *
- * Detects and extracts:
- * - `| head -n N` / `| head -N` - extracted to headLines
- * - `| tail -n N` / `| tail -N` - extracted to tailLines
- */
-
-export interface NormalizedCommand {
-	/** Cleaned command with patterns stripped */
-	command: string;
-	/** Extracted head line count, if any */
-	headLines?: number;
-	/** Extracted tail line count, if any */
-	tailLines?: number;
-}
-
-/**
- * Pattern to match trailing pipe to head/tail.
- * Captures: full match, command (head/tail), line count
- *
- * Matches:
- * - `| head -n 50`
- * - `| head -50`
- * - `| tail -n 100`
- * - `| tail -100`
- *
- * Does NOT match head/tail with other flags or without line count.
- */
-const TRAILING_HEAD_TAIL_PATTERN = /\|\s*(head|tail)\s+(?:-n\s*(\d+)|(-\d+))\s*$/;
-
-/**
- * Normalize a bash command by stripping patterns better handled natively.
- *
- * Extracts `| head -n N` and `| tail -n N` suffixes into separate fields
- * so they can be applied post-execution without breaking streaming.
- *
- * Strips `2>&1` since we already merge stdout/stderr.
- */
-export function normalizeBashCommand(command: string): NormalizedCommand {
-	let normalized = command;
-	let headLines: number | undefined;
-	let tailLines: number | undefined;
-
-	// Extract trailing head/tail
-	const match = normalized.match(TRAILING_HEAD_TAIL_PATTERN);
-	if (match) {
-		const [fullMatch, cmd, nValue, dashValue] = match;
-		const lineCount = nValue ? Number.parseInt(nValue, 10) : Number.parseInt(dashValue.slice(1), 10);
-
-		if (cmd === "head") {
-			headLines = lineCount;
-		} else {
-			tailLines = lineCount;
-		}
-
-		normalized = normalized.slice(0, -fullMatch.length);
-	}
-
-	// Preserve internal whitespace (important for heredocs / indentation-sensitive scripts)
-	normalized = normalized.trim();
-
-	return {
-		command: normalized,
-		headLines,
-		tailLines,
-	};
-}
-
-/**
- * Apply head/tail limits to output text.
- *
- * If both head and tail are specified, head is applied first (take first N lines),
- * then tail is applied (take last M lines of that).
- */
-export function applyHeadTail(
-	text: string,
-	headLines?: number,
-	tailLines?: number,
-): { text: string; applied: boolean; headApplied?: number; tailApplied?: number } {
-	if (!headLines && !tailLines) {
-		return { text, applied: false };
-	}
-
-	let lines = text.split("\n");
-	let headApplied: number | undefined;
-	let tailApplied: number | undefined;
-
-	// Apply head first (keep first N lines)
-	if (headLines !== undefined && headLines > 0 && lines.length > headLines) {
-		lines = lines.slice(0, headLines);
-		headApplied = headLines;
-	}
-
-	// Then apply tail (keep last N lines)
-	if (tailLines !== undefined && tailLines > 0 && lines.length > tailLines) {
-		lines = lines.slice(-tailLines);
-		tailApplied = tailLines;
-	}
-
-	return {
-		text: lines.join("\n"),
-		applied: headApplied !== undefined || tailApplied !== undefined,
-		headApplied,
-		tailApplied,
-	};
-}