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

package/src/tools/read.ts

@@ -73,20 +73,6 @@ const PROSE_SUMMARY_EXTENSIONS = new Set([".md", ".txt"]);
 // Remote mount path prefix (sshfs mounts) - skip fuzzy matching to avoid hangs
 const REMOTE_MOUNT_PREFIX = getRemoteDir() + path.sep;
 
-const READ_DIRECTORY_EXCLUDED_DIRS = new Set([
-	"node_modules",
-	".git",
-	".next",
-	"dist",
-	"build",
-	"target",
-	".venv",
-	".cache",
-	".turbo",
-	".parcel-cache",
-	"coverage",
-]);
-
 function isRemoteMountPath(absolutePath: string): boolean {
 	return absolutePath.startsWith(REMOTE_MOUNT_PREFIX);
 }
@@ -476,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" };
@@ -667,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;
@@ -1153,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);
@@ -1164,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);
@@ -1178,7 +1199,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				limit,
 				{ ...archivePath, archiveSubPath: archiveSubPath.path },
 				signal,
-				{ raw: archiveParsed.kind === "raw" },
+				{ raw: isRawSelector(archiveParsed) },
 			);
 		}
 
@@ -1307,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),
@@ -1435,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;
@@ -1524,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).
@@ -1564,6 +1590,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			sourceInternal: url,
 			entityLabel: "resource",
 			ignoreResultLimits: scheme === "skill",
+			immutable: resource.immutable,
+			raw: options?.raw,
 		});
 	}
 
@@ -1581,15 +1609,9 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		try {
 			tree = await buildDirectoryTree(absolutePath, {
 				maxDepth: READ_DIRECTORY_MAX_DEPTH,
-				directoryEntryLimit: READ_DIRECTORY_CHILD_LIMIT,
-				rootEntryLimit: null,
+				perDirLimit: READ_DIRECTORY_CHILD_LIMIT,
+				rootLimit: null,
 				lineCap: limit ?? null,
-				lineCapProtectedDepth: 1,
-				hidden: true,
-				gitignore: false,
-				cache: true,
-				excludedDirectoryNames: READ_DIRECTORY_EXCLUDED_DIRS,
-				rootLabel: ".",
 			});
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);

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),