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

package/src/tools/search.ts

@@ -1,7 +1,8 @@
-import { mkdtemp, rm, stat, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { access, mkdtemp, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import * as path from "node:path";
-import { computeFileHash, formatHashlineHeader } from "@oh-my-pi/hashline";
+import { formatHashlineHeader } from "@oh-my-pi/hashline";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type GrepMatch, GrepOutputMode, type GrepResult, grep } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
@@ -478,8 +479,8 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 						);
 					}
 				} catch (err) {
-					if (err instanceof Error && err.message.startsWith("regex parse error")) {
-						throw new ToolError(err.message);
+					if (err instanceof Error && /^regex(?: parse)? error/i.test(err.message)) {
+						throw new ToolError(err.message.replace(/^regex(?: parse)? error:?\s*/i, "Invalid regex: "));
 					}
 					throw err;
 				}
@@ -609,16 +610,16 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					matchesByFile.get(relativePath)!.push(match);
 				}
 				const displayLines: string[] = [];
-				const hashContexts = new Map<string, { absolutePath: string; fileHash: string }>();
+				const hashContexts = new Map<string, { absolutePath: string; tag?: string }>();
+				const snapshotStore = baseDisplayMode.hashLines ? getFileSnapshotStore(this.session) : undefined;
 				if (baseDisplayMode.hashLines) {
 					for (const relativePath of fileList) {
 						if (archiveDisplaySet.has(relativePath)) continue;
 						const absoluteFilePath = path.resolve(this.session.cwd, relativePath);
 						if (immutableSourcePaths.has(absoluteFilePath)) continue;
 						try {
-							const fullText = await Bun.file(absoluteFilePath).text();
-							const fileHash = computeFileHash(fullText);
-							hashContexts.set(relativePath, { absolutePath: absoluteFilePath, fileHash });
+							await access(absoluteFilePath, constants.R_OK);
+							hashContexts.set(relativePath, { absolutePath: absoluteFilePath });
 						} catch {
 							// Best-effort: if the file disappeared between grep and render, fall back to plain line output.
 						}
@@ -671,9 +672,8 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 						fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
 					}
 					if (cacheEntries.length > 0 && hashContext) {
-						getFileSnapshotStore(this.session).recordSparse(hashContext.absolutePath, cacheEntries, {
-							fileHash: hashContext.fileHash,
-						});
+						const tag = snapshotStore?.recordSparse(hashContext.absolutePath, cacheEntries);
+						if (tag) hashContext.tag = tag;
 					}
 					return { model: modelOut, display: displayOut };
 				};
@@ -684,7 +684,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 						return {
 							modelLines: rendered.model,
 							displayLines: rendered.display,
-							headerSuffix: hashContext ? `#${hashContext.fileHash}` : "",
+							headerSuffix: hashContext?.tag ? `#${hashContext.tag}` : "",
 							skip: rendered.model.length === 0,
 						};
 					});
@@ -699,8 +699,8 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 							displayLines.push("");
 						}
 						const hashContext = hashContexts.get(relativePath);
-						if (hashContext) {
-							outputLines.push(formatHashlineHeader(relativePath, hashContext.fileHash));
+						if (hashContext?.tag) {
+							outputLines.push(formatHashlineHeader(relativePath, hashContext.tag));
 						}
 						outputLines.push(...rendered.model);
 						displayLines.push(...rendered.display);

package/src/tools/tts.ts

@@ -0,0 +1,133 @@
+// Ported from NousResearch/hermes-agent (MIT) — tools/tts_tool.py L167-171, L896-959.
+
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import type { CustomTool, CustomToolContext } from "../extensibility/custom-tools/types";
+import { ohMyPiXAIUserAgent, resolveXAIHttpCredentials } from "../lib/xai-http";
+import { formatPathRelativeToCwd, resolveToCwd } from "./path-utils";
+
+// Hermes tts_tool.py L167-171
+const DEFAULT_XAI_VOICE_ID = "eve" as const;
+const DEFAULT_XAI_LANGUAGE = "en" as const;
+const DEFAULT_XAI_SAMPLE_RATE = 24_000;
+const DEFAULT_XAI_BIT_RATE = 128_000;
+const XAI_MAX_TEXT_LENGTH = 15_000;
+
+// Built-in voices per xAI Tier-1 docs (2026-05-16). xAI also accepts custom voice IDs,
+// so the schema does NOT enum-restrict voice_id; this constant only drives the description.
+const XAI_BUILTIN_VOICES = ["ara", "eve", "leo", "rex", "sal"] as const;
+
+const formatVoiceList = (): string =>
+	XAI_BUILTIN_VOICES.map(v => (v === DEFAULT_XAI_VOICE_ID ? `${v} (default)` : v)).join(", ");
+
+type TtsCodec = "mp3" | "wav";
+
+const ttsSchema = z.object({
+	text: z.string().min(1).max(XAI_MAX_TEXT_LENGTH),
+	voice_id: z.string().default(DEFAULT_XAI_VOICE_ID),
+	language: z.string().default(DEFAULT_XAI_LANGUAGE),
+	output_path: z.string(),
+	sample_rate: z.number().int().optional(),
+	bit_rate: z.number().int().optional(),
+});
+
+interface TtsToolDetails {
+	bytes: number;
+	voiceId: string;
+	codec: TtsCodec;
+}
+
+export const ttsTool: CustomTool<typeof ttsSchema, TtsToolDetails> = {
+	name: "tts",
+	label: "TextToSpeech",
+	strict: false,
+	approval: "write",
+	description:
+		`Synthesize speech from text using xAI Grok Voice. Built-in voices: ${formatVoiceList()}. ` +
+		"Custom voice IDs also accepted. Output codec inferred from output_path suffix (.wav → wav, else mp3). " +
+		`Max ${XAI_MAX_TEXT_LENGTH.toLocaleString("en-US")} characters.`,
+	parameters: ttsSchema,
+	async execute(
+		_toolCallId: string,
+		params: z.infer<typeof ttsSchema>,
+		_onUpdate,
+		ctx: CustomToolContext,
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<TtsToolDetails, typeof ttsSchema>> {
+		const creds = await resolveXAIHttpCredentials(ctx.modelRegistry);
+		if (!creds) {
+			return {
+				isError: true,
+				content: [
+					{
+						type: "text",
+						text: "No xAI credentials. Run /login → xAI Grok OAuth (SuperGrok Subscription) or set XAI_API_KEY.",
+					},
+				],
+			};
+		}
+
+		const cwd = ctx.sessionManager.getCwd();
+		const outputPath = resolveToCwd(params.output_path, cwd);
+		const displayPath = formatPathRelativeToCwd(outputPath, cwd);
+		const codec: TtsCodec = outputPath.toLowerCase().endsWith(".wav") ? "wav" : "mp3";
+		const voiceId = params.voice_id;
+		const language = params.language;
+		const sampleRate = params.sample_rate ?? DEFAULT_XAI_SAMPLE_RATE;
+		const bitRate = params.bit_rate ?? DEFAULT_XAI_BIT_RATE;
+
+		const payload: Record<string, unknown> = {
+			text: params.text,
+			voice_id: voiceId,
+			language,
+		};
+		// Hermes tts_tool.py L926-940 — only send output_format when caller overrides a default.
+		const codecOverridden = codec !== "mp3";
+		const sampleRateOverridden = sampleRate !== DEFAULT_XAI_SAMPLE_RATE;
+		const bitRateOverridden = codec === "mp3" && bitRate !== DEFAULT_XAI_BIT_RATE;
+		if (codecOverridden || sampleRateOverridden || bitRateOverridden) {
+			const fmt: Record<string, unknown> = { codec };
+			if (sampleRate) fmt.sample_rate = sampleRate;
+			if (codec === "mp3" && bitRate) fmt.bit_rate = bitRate;
+			payload.output_format = fmt;
+		}
+
+		// Compose the caller signal with a 60 s timeout fence.
+		const timeoutSignal = AbortSignal.timeout(60_000);
+		const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+
+		const response = await fetch(`${creds.baseURL}/tts`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${creds.apiKey}`,
+				"Content-Type": "application/json",
+				"User-Agent": ohMyPiXAIUserAgent(),
+			},
+			body: JSON.stringify(payload),
+			signal: combinedSignal,
+		});
+		if (!response.ok) {
+			const detail = await response.text();
+			return {
+				isError: true,
+				content: [
+					{
+						type: "text",
+						text: `xAI TTS failed (${response.status}): ${detail.slice(0, 300)}`,
+					},
+				],
+			};
+		}
+		const bytes = new Uint8Array(await response.arrayBuffer());
+		await Bun.write(outputPath, bytes);
+		return {
+			content: [
+				{
+					type: "text",
+					text: `Saved ${bytes.length} bytes to ${displayPath} (voice=${voiceId}, codec=${codec}).`,
+				},
+			],
+			details: { bytes: bytes.length, voiceId, codec },
+		};
+	},
+};

package/src/tools/write.ts

@@ -1,12 +1,14 @@
 import { Database } from "bun:sqlite";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+
 import { stripHashlinePrefixes } from "@oh-my-pi/hashline";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } 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 { isEnoent, isRecord, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
+
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { InternalUrlRouter } from "../internal-urls";
 import { parseInternalUrl } from "../internal-urls/parse";
@@ -53,6 +55,8 @@ import {
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
+const LOOSE_HASHLINE_HEADER_RE = /^\s*¶\S+#[^ \t\r\n]*\s*$/;
+
 let fflateModulePromise: Promise<typeof import("fflate")> | undefined;
 async function loadFflate(): Promise<typeof import("fflate")> {
 	if (!fflateModulePromise) fflateModulePromise = import("fflate");
@@ -70,6 +74,33 @@ export type WriteToolInput = z.infer<typeof writeSchema>;
 export interface WriteToolDetails {
 	diagnostics?: FileDiagnosticsResult;
 	meta?: OutputMeta;
+	/** Set when the file was auto-chmod'd because content begins with a `#!` shebang. */
+	madeExecutable?: boolean;
+}
+
+/**
+ * Strip hashline display prefixes from write content.
+ *
+ * Includes a fallback for loosely-formed section headers that still carry
+ * line-number prefixes (for example legacy or malformed hashline echoes).
+ */
+function stripWriteContentWithPotentialLooseHeader(lines: string[]): { text: string; stripped: boolean } {
+	const cleaned = stripHashlinePrefixes(lines);
+	if (cleaned !== lines) {
+		return { text: cleaned.join("\n"), stripped: true };
+	}
+
+	const headerIndex = lines.findIndex(line => line.trim().length > 0);
+	if (headerIndex === -1 || !LOOSE_HASHLINE_HEADER_RE.test(lines[headerIndex])) {
+		return { text: lines.join("\n"), stripped: false };
+	}
+
+	const linesWithoutHeader = lines.slice(0, headerIndex).concat(lines.slice(headerIndex + 1));
+	const cleanedWithoutHeader = stripHashlinePrefixes(linesWithoutHeader);
+	if (cleanedWithoutHeader === linesWithoutHeader) {
+		return { text: lines.join("\n"), stripped: false };
+	}
+	return { text: cleanedWithoutHeader.join("\n"), stripped: true };
 }
 
 /**
@@ -82,10 +113,7 @@ function stripWriteContent(session: ToolSession, content: string): { text: strin
 	if (!resolveFileDisplayMode(session).hashLines) {
 		return { text: content, stripped: false };
 	}
-	const lines = content.split("\n");
-	const cleaned = stripHashlinePrefixes(lines);
-	if (cleaned === lines) return { text: content, stripped: false };
-	return { text: cleaned.join("\n"), stripped: true };
+	return stripWriteContentWithPotentialLooseHeader(content.split("\n"));
 }
 
 /**
@@ -103,6 +131,28 @@ function appendNoteToResult(result: AgentToolResult<WriteToolDetails>, note: str
 	}
 }
 
+/**
+ * If `content` begins with a `#!` shebang, ensure the file is executable.
+ *
+ * Mirrors `chmod a+x` (adds user/group/other execute bits to existing mode).
+ * Errors are swallowed: chmod failure (e.g. Windows ACL, read-only mount)
+ * MUST NOT fail an otherwise successful write. Returns whether the mode
+ * actually changed so the caller can surface a note.
+ */
+async function maybeMarkExecutableForShebang(absolutePath: string, content: string): Promise<boolean> {
+	if (!content.startsWith("#!")) return false;
+	try {
+		const stat = await fs.stat(absolutePath);
+		const currentMode = stat.mode & 0o7777;
+		const newMode = currentMode | 0o111;
+		if (newMode === currentMode) return false;
+		await fs.chmod(absolutePath, newMode);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Tool Class
 // ═══════════════════════════════════════════════════════════════════════════
@@ -772,6 +822,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 
 			const diagnostics = await this.#writethrough(absolutePath, cleanContent, signal, undefined, batchRequest);
 			invalidateFsScanAfterWrite(absolutePath);
+			const madeExecutable = await maybeMarkExecutableForShebang(absolutePath, cleanContent);
 
 			const displayPath = formatPathRelativeToCwd(absolutePath, this.session.cwd);
 			let resultText = `Successfully wrote ${cleanContent.length} bytes to ${displayPath}`;
@@ -781,7 +832,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 			if (!diagnostics) {
 				return {
 					content: [{ type: "text", text: resultText }],
-					details: {},
+					details: { madeExecutable: madeExecutable || undefined },
 				};
 			}
 
@@ -789,6 +840,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 				content: [{ type: "text", text: resultText }],
 				details: {
 					diagnostics,
+					madeExecutable: madeExecutable || undefined,
 					meta: outputMeta()
 						.diagnostics(diagnostics.summary, diagnostics.messages ?? [])
 						.get(),
@@ -915,13 +967,16 @@ export const writeToolRenderer = {
 		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
 		const lineCount = countLines(fileContent);
 		const lineSuffix = formatLineCountSuffix(lineCount, uiTheme);
+		const execSuffix = result.details?.madeExecutable
+			? `${uiTheme.fg("dim", " · ")}${uiTheme.fg("success", "made executable!")}`
+			: "";
 
 		// Build header with status icon
 		const header = renderStatusLine(
 			{
 				icon: "success",
 				title: "Write",
-				description: `${langIcon} ${pathDisplay}${lineSuffix}`,
+				description: `${langIcon} ${pathDisplay}${lineSuffix}${execSuffix}`,
 			},
 			uiTheme,
 		);

package/src/utils/file-mentions.ts

@@ -7,12 +7,13 @@
  */
 import * as fs from "node:fs/promises";
 import path from "node:path";
-import { computeFileHash, formatHashlineHeader, formatNumberedLines } from "@oh-my-pi/hashline";
+import { formatHashlineHeader, formatNumberedLines, type SnapshotStore } from "@oh-my-pi/hashline";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { glob } from "@oh-my-pi/pi-natives";
 import { fuzzyMatch } from "@oh-my-pi/pi-tui";
 import { formatAge, formatBytes, readImageMetadata } from "@oh-my-pi/pi-utils";
+import { normalizeToLF } from "../edit/normalize";
 import type { FileMentionMessage } from "../session/messages";
 import {
 	DEFAULT_MAX_BYTES,
@@ -277,7 +278,7 @@ export function extractFileMentions(text: string): string[] {
 export async function generateFileMentionMessages(
 	filePaths: string[],
 	cwd: string,
-	options?: { autoResizeImages?: boolean; useHashLines?: boolean },
+	options?: { autoResizeImages?: boolean; useHashLines?: boolean; snapshotStore?: SnapshotStore },
 ): Promise<AgentMessage[]> {
 	if (filePaths.length === 0) return [];
 
@@ -354,9 +355,14 @@ export async function generateFileMentionMessages(
 			}
 
 			const content = await Bun.file(absolutePath).text();
-			let { output, lineCount } = buildTextOutput(content);
-			if (options?.useHashLines) {
-				output = `${formatHashlineHeader(resolvedPath, computeFileHash(content))}\n${formatNumberedLines(output)}`;
+			const snapshotStore = options?.useHashLines ? options.snapshotStore : undefined;
+			const normalized = snapshotStore ? normalizeToLF(content) : content;
+			let { output, lineCount } = buildTextOutput(normalized);
+			if (snapshotStore) {
+				const tag = snapshotStore.recordContiguous(absolutePath, 1, normalized.split("\n"), {
+					fullText: normalized,
+				});
+				output = `${formatHashlineHeader(resolvedPath, tag)}\n${formatNumberedLines(output)}`;
 			}
 			files.push({ path: resolvedPath, content: output, lineCount });
 		} catch {

package/src/web/search/providers/codex.ts

@@ -19,8 +19,9 @@ import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const CODEX_RESPONSES_PATH = "/codex/responses";
-const FALLBACK_MODEL = "gpt-5.4";
+const FALLBACK_MODEL = "gpt-5.5";
 const DEFAULT_MODEL_PREFERENCES = [
+	"gpt-5.5",
 	"gpt-5.4",
 	"gpt-5-codex",
 	"gpt-5",