@oh-my-pi/pi-coding-agent 14.5.12 → 14.5.14

package/src/config.ts

@@ -11,7 +11,7 @@ import {
 } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
-import { Ajv, type ErrorObject, type ValidateFunction } from "ajv";
+import type { ErrorObject } from "ajv";
 import { JSONC, YAML } from "bun";
 import { expandTilde } from "./tools/path-utils";
 
@@ -143,7 +143,6 @@ export type LoadResult<T> =
 	| { value: T; error?: undefined; status: "ok" }
 	| { value?: null; error?: unknown; status: "not-found" };
 
-const ajv = new Ajv();
 export class ConfigFile<T> implements IConfigFile<T> {
 	readonly #basePath: string;
 	#cache?: LoadResult<T>;
@@ -175,6 +174,15 @@ export class ConfigFile<T> implements IConfigFile<T> {
 		return result;
 	}
 
+	getMtimeMs(): number | null {
+		try {
+			return fs.statSync(this.path()).mtimeMs;
+		} catch (err) {
+			if (isEnoent(err)) return null;
+			throw err;
+		}
+	}
+
 	withValidation(name: string, validate: (value: T) => void): this {
 		const prev = this.#auxValidate;
 		this.#auxValidate = (value: T) => {
@@ -212,13 +220,17 @@ export class ConfigFile<T> implements IConfigFile<T> {
 				throw new Error(`Invalid config file path: ${this.#basePath}`);
 			}
 
-			const validate = ajv.compile(this.schema) as ValidateFunction<T>;
-			if (!validate(parsed)) {
-				const error = new ConfigError(this.id, validate.errors);
+			if (!Value.Check(this.schema, parsed)) {
+				const schemaErrors: ErrorObject[] = [];
+				for (const err of Value.Errors(this.schema, parsed)) {
+					schemaErrors.push({ instancePath: err.path, message: err.message } as ErrorObject);
+					if (schemaErrors.length >= 50) break;
+				}
+				const error = new ConfigError(this.id, schemaErrors);
 				logger.warn("Failed to parse config file", { path: this.path(), error });
 				return this.#storeCache({ error, status: "error" });
 			}
-			return this.#storeCache({ value: parsed, status: "ok" });
+			return this.#storeCache({ value: parsed as T, status: "ok" });
 		} catch (error) {
 			if (isEnoent(error)) {
 				return this.#storeCache({ status: "not-found" });

package/src/eval/backend.ts

@@ -0,0 +1,43 @@
+import type { ToolSession } from "../tools";
+import type { EvalDisplayOutput, EvalLanguage } from "./types";
+
+/** Per-cell execute() options. */
+export interface ExecutorBackendExecOptions {
+	cwd: string;
+	sessionId: string;
+	sessionFile: string | undefined;
+	kernelOwnerId: string | undefined;
+	signal?: AbortSignal;
+	session: ToolSession;
+	deadlineMs: number;
+	reset: boolean;
+	artifactPath: string | undefined;
+	artifactId: string | undefined;
+	onChunk: (chunk: string) => void;
+}
+
+/** Result returned by a backend's execute(). */
+export interface ExecutorBackendResult {
+	output: string;
+	exitCode: number | undefined;
+	cancelled: boolean;
+	truncated: boolean;
+	artifactId: string | undefined;
+	totalLines: number;
+	totalBytes: number;
+	outputLines: number;
+	outputBytes: number;
+	displayOutputs: EvalDisplayOutput[];
+}
+
+/** Pluggable language backend for the eval tool. */
+export interface ExecutorBackend {
+	readonly id: EvalLanguage;
+	readonly label: string;
+	/** Source language identifier passed to the syntax highlighter (e.g. "python", "javascript"). */
+	readonly highlightLang: string;
+	/** Cheap availability check. Used by fallback resolution. */
+	isAvailable(session: ToolSession): Promise<boolean>;
+	/** Execute one cell. Caller invokes once per cell and aggregates results. */
+	execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult>;
+}

package/src/eval/eval.lark

@@ -0,0 +1,43 @@
+%import common.LF
+%import common.WS_INLINE
+
+// Strict canonical surface for the eval tool. Callers MUST emit exactly this
+// form. The runtime parser accepts additional lenient shapes (positional
+// title/duration, alias keys, long-form lang tokens, mixed casing, fence
+// runs of any length ≥ 3, etc.) but those are fallback only and MUST NOT
+// be relied on.
+//
+// Each cell is a fenced code block opened and closed by exactly three
+// (or exactly five) backticks or tildes — five lets callers nest a 3-char
+// fence inside a cell verbatim. The opening fence carries an optional info
+// string with up to four parts, IN THIS ORDER:
+//
+//   lang?  id_attr?  t_attr?  rst_attr?
+//
+// where:
+//   lang    = "py" | "js" | "ts"
+//   id_attr = id="..."        (double-quoted cell id)
+//   t_attr  = t=<duration>    (bare integer with optional ms/s/m unit)
+//   rst_attr= rst=0|1         (per-language kernel reset for this cell)
+
+start: cell+
+
+cell: backtick_cell | tilde_cell
+
+backtick_cell: BACKTICKS info? LF code_line* BACKTICKS LF
+tilde_cell:    TILDES   info? LF code_line* TILDES   LF
+
+info: lang (WS_INLINE id_attr)? (WS_INLINE t_attr)? (WS_INLINE rst_attr)?
+    | id_attr (WS_INLINE t_attr)? (WS_INLINE rst_attr)?
+    | t_attr (WS_INLINE rst_attr)?
+    | rst_attr
+
+lang:     "py" | "js" | "ts"
+id_attr:  "id="  /"[^"\r\n]*"/
+t_attr:   "t="   /\d+(ms|s|m)?/
+rst_attr: "rst=" /[01]/
+
+code_line: /[^\r\n]*/ LF
+
+BACKTICKS: "```"   | "`````"
+TILDES:    "~~~"   | "~~~~~"

package/src/eval/index.ts

@@ -0,0 +1,5 @@
+export * from "./backend";
+export { default as jsBackend } from "./js";
+export * from "./parse";
+export { default as pythonBackend } from "./py";
+export * from "./types";