@oh-my-pi/pi-coding-agent 15.12.3 → 15.13.0

package/src/edit/modes/replace.ts

@@ -5,7 +5,7 @@
  * fallback strategies for finding text in files.
  */
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
 import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";

package/src/eval/__tests__/budget-bridge.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import type { GoalModeState } from "../../goals/state";
-import type { UsageStatistics } from "../../session/session-manager";
+import type { UsageStatistics } from "../../session/session-entries";
 import type { ToolSession } from "../../tools";
 import { runEvalBudget } from "../budget-bridge";
 

package/src/eval/agent-bridge.ts

@@ -5,7 +5,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { prompt, Snowflake } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { resolveAgentModelPatterns } from "../config/model-resolver";
 import type { LocalProtocolOptions } from "../internal-urls";
 import { MCPManager } from "../mcp/manager";

package/src/eval/completion-bridge.ts

@@ -14,7 +14,7 @@
 import { instrumentedCompleteSimple, resolveTelemetry } from "@oh-my-pi/pi-agent-core";
 import { type Api, Effort, type Model, type Tool } from "@oh-my-pi/pi-ai";
 import { getSupportedEfforts } from "@oh-my-pi/pi-catalog/model-thinking";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { extractTextContent, extractToolCall, parseJsonPayload } from "../commit/utils";
 
 import {

package/src/eval/js/shared/prelude.txt

@@ -1,33 +1,85 @@
 if (!globalThis.__omp_js_prelude_loaded__) {
 	globalThis.__omp_js_prelude_loaded__ = true;
 
+	const isNil = value => value === undefined || value === null;
 	const isPlainObject = value => value !== null && typeof value === "object" && !Array.isArray(value);
-	const optionsArg = (name, value, rest, example) => {
-		if (rest.length > 0) {
-			throw new TypeError(
-				`${name}() takes options as a single trailing object literal, not positional arguments (got ${rest.length + 1} extra args). Pass them as ${name}(..., ${example}).`,
-			);
+	const positionalOptions = (name, args, keys, example) => {
+		for (let index = keys.length; index < args.length; index++) {
+			if (!isNil(args[index])) {
+				throw new TypeError(
+					`${name}() accepts at most ${keys.length} positional optional args; got ${args.length}. Pass ${name}(..., ${example}) for named options.`,
+				);
+			}
+		}
+		const options = {};
+		for (let index = 0; index < keys.length && index < args.length; index++) {
+			const value = args[index];
+			if (!isNil(value)) options[keys[index]] = value;
+		}
+		return options;
+	};
+	const optionsArg = (name, value, rest, keys, example) => {
+		if (isNil(value)) return positionalOptions(name, [value, ...rest], keys, example);
+		if (isPlainObject(value)) {
+			if (rest.some(arg => !isNil(arg))) {
+				throw new TypeError(
+					`${name}() takes either a single trailing options object like ${example} or positional optional args; do not mix both forms.`,
+				);
+			}
+			return value;
 		}
-		if (value === undefined || value === null) return {};
-		if (!isPlainObject(value)) {
-			const kind = Array.isArray(value) ? "an array" : typeof value;
+		if (typeof value === "object") {
+			const kind = Array.isArray(value) ? "an array" : value.constructor?.name ?? "object";
 			throw new TypeError(
-				`${name}() options must be a trailing object literal like ${example}, not ${kind}. JS helpers never take positional options.`,
+				`${name}() options must be a plain object like ${example}, null/undefined, or positional optional args, not ${kind}.`,
 			);
 		}
-		return value;
+		return positionalOptions(name, [value, ...rest], keys, example);
 	};
 	const callHelper = (name, ...args) => globalThis.__omp_helpers__[name](...args);
+	const hasScheme = path => typeof path === "string" && /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(path);
+	const shouldDelegateRead = path => hasScheme(path) && !path.toLowerCase().startsWith("local://");
+	const withReadLineSelector = (path, options) => {
+		const offset = typeof options.offset === "number" ? options.offset : 1;
+		const limit = typeof options.limit === "number" ? options.limit : undefined;
+		if (offset <= 1 && limit === undefined) return path;
+		if (limit !== undefined && limit <= 0) return null;
+		const start = Math.max(1, offset);
+		if (limit === undefined) return `${path}:${start}-`;
+		return `${path}:${start}-${start + limit - 1}`;
+	};
+	const readToolText = async path => {
+		const res = await globalThis.__omp_call_tool__("read", { path });
+		return res && typeof res === "object" && "text" in res ? res.text : res;
+	};
 
-	const read = (path, opts, ...rest) => callHelper("read", path, optionsArg("read", opts, rest, "{ offset, limit }"));
+
+	const read = async (path, opts, ...rest) => {
+		const options = optionsArg("read", opts, rest, ["offset", "limit"], "{ offset, limit }");
+		if (shouldDelegateRead(path)) {
+			const toolPath = withReadLineSelector(path, options);
+			return toolPath === null ? "" : readToolText(toolPath);
+		}
+		return callHelper("read", path, options);
+	};
 	const write = async (path, data) => callHelper("writeFile", path, data);
 	const append = (path, content) => callHelper("append", path, content);
-	const sort = (text, opts, ...rest) => callHelper("sortText", text, optionsArg("sort", opts, rest, "{ reverse, unique }"));
-	const uniq = (text, opts, ...rest) => callHelper("uniqText", text, optionsArg("uniq", opts, rest, "{ count }"));
+	const sort = (text, opts, ...rest) =>
+		callHelper("sortText", text, optionsArg("sort", opts, rest, ["reverse", "unique"], "{ reverse, unique }"));
+	const uniq = (text, opts, ...rest) => callHelper("uniqText", text, optionsArg("uniq", opts, rest, ["count"], "{ count }"));
 	const counter = (items, opts, ...rest) =>
-		callHelper("counter", items, optionsArg("counter", opts, rest, "{ limit, reverse }"));
+		callHelper("counter", items, optionsArg("counter", opts, rest, ["limit", "reverse"], "{ limit, reverse }"));
 	const diff = (a, b) => callHelper("diff", a, b);
-	const tree = (path = ".", opts, ...rest) => callHelper("tree", path, optionsArg("tree", opts, rest, "{ maxDepth, showHidden }"));
+	const tree = (path = ".", opts, ...rest) => {
+		if (isPlainObject(path) && opts === undefined && rest.length === 0) {
+			return callHelper("tree", ".", path);
+		}
+		return callHelper(
+			"tree",
+			isNil(path) ? "." : path,
+			optionsArg("tree", opts, rest, ["maxDepth", "showHidden"], "{ maxDepth, showHidden }"),
+		);
+	};
 	const env = (key, value) => callHelper("env", key, value);
 
 	const tool = new Proxy(
@@ -58,14 +110,14 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 	const hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
 
 	const completion = async (prompt, opts, ...rest) => {
-		const o = optionsArg("completion", opts, rest, "{ model, system, schema }");
+		const o = optionsArg("completion", opts, rest, ["model", "system", "schema"], "{ model, system, schema }");
 		const res = await globalThis.__omp_call_tool__("__completion__", { prompt, ...o });
 		const text = res && typeof res === "object" ? res.text : res;
 		return hasOwn(o, "schema") ? JSON.parse(text) : text;
 	};
 
 	const agent = async (prompt, opts, ...rest) => {
-		const o = optionsArg("agent", opts, rest, "{ agentType, model, label, schema }");
+		const o = optionsArg("agent", opts, rest, ["agentType", "model", "label", "schema"], "{ agentType, model, label, schema }");
 		const res = await globalThis.__omp_call_tool__("__agent__", { prompt, ...o });
 		const text = res && typeof res === "object" ? res.text : res;
 		return hasOwn(o, "schema") ? JSON.parse(text) : text;

package/src/export/html/index.ts

@@ -3,12 +3,9 @@ import * as path from "node:path";
 import type { AgentState } from "@oh-my-pi/pi-agent-core";
 import { APP_NAME, isEnoent } from "@oh-my-pi/pi-utils";
 import { getResolvedThemeColors, getThemeExportColors } from "../../modes/theme/theme";
-import {
-	loadEntriesFromFile,
-	type SessionEntry,
-	type SessionHeader,
-	SessionManager,
-} from "../../session/session-manager";
+import type { SessionEntry, SessionHeader } from "../../session/session-entries";
+import { loadEntriesFromFile } from "../../session/session-loader";
+import { SessionManager } from "../../session/session-manager";
 import templateCss from "./template.css" with { type: "text" };
 import templateHtml from "./template.html" with { type: "text" };
 import templateJs from "./template.js" with { type: "text" };

package/src/export/html/template.js

@@ -450,6 +450,26 @@
         return div.innerHTML;
       }
 
+      function isDotOnlyThinking(text) {
+        let sawDot = false;
+        for (let i = 0; i < text.length; i++) {
+          const code = text.charCodeAt(i);
+          if (code === 0x2e || code === 0x2026) {
+            sawDot = true;
+            continue;
+          }
+          if (code === 0x20 || code === 0x09 || code === 0x0a || code === 0x0d) continue;
+          return false;
+        }
+        return sawDot;
+      }
+
+      function visibleThinkingText(block) {
+        const text = block.thinking.trim();
+        if (!text) return '';
+        return isDotOnlyThinking(text) ? '' : text;
+      }
+
       /**
        * Truncate string to maxLen chars, append "..." if truncated.
        */
@@ -1056,9 +1076,11 @@
             for (const block of msg.content) {
               if (block.type === 'text' && block.text.trim()) {
                 html += `<div class="assistant-text markdown-content">${safeMarkedParse(block.text)}</div>`;
-              } else if (block.type === 'thinking' && block.thinking.trim()) {
+              } else if (block.type === 'thinking') {
+                const thinking = visibleThinkingText(block);
+                if (!thinking) continue;
                 html += `<div class="thinking-block">
-                  <div class="thinking-text">${escapeHtml(block.thinking)}</div>
+                  <div class="thinking-text">${escapeHtml(thinking)}</div>
                   <div class="thinking-collapsed">Thinking ...</div>
                 </div>`;
               }