@oh-my-pi/pi-coding-agent 15.0.0 → 15.0.2

package/src/config.ts

@@ -1,20 +1,11 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import {
-	CONFIG_DIR_NAME,
-	getAgentDir,
-	getConfigAgentDirName,
-	getProjectDir,
-	isEnoent,
-	logger,
-} from "@oh-my-pi/pi-utils";
-import type { TSchema } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
-import type { ErrorObject } from "ajv";
-import { JSONC, YAML } from "bun";
+import { CONFIG_DIR_NAME, getConfigAgentDirName, getProjectDir } from "@oh-my-pi/pi-utils";
 import { expandTilde } from "./tools/path-utils";
 
+export * from "./config/config-file";
+
 const priorityList = [
 	{ dir: CONFIG_DIR_NAME, globalAgentDir: getConfigAgentDirName },
 	{ dir: ".claude" },
@@ -53,213 +44,6 @@ export function getChangelogPath(): string {
 	return path.resolve(path.join(getPackageDir(), "CHANGELOG.md"));
 }
 
-// =============================================================================
-// User Config Paths (~/.omp/agent/*)
-// =============================================================================
-
-function migrateJsonToYml(jsonPath: string, ymlPath: string) {
-	try {
-		if (fs.existsSync(ymlPath)) return;
-		if (!fs.existsSync(jsonPath)) return;
-
-		const content = fs.readFileSync(jsonPath, "utf-8");
-		const parsed = JSON.parse(content);
-		if (!parsed) {
-			logger.warn("migrateJsonToYml: invalid json structure", { path: jsonPath });
-			return;
-		}
-		fs.writeFileSync(ymlPath, YAML.stringify(parsed, null, 2));
-	} catch (error) {
-		logger.warn("migrateJsonToYml: migration failed", { error: String(error) });
-	}
-}
-
-export interface IConfigFile<T> {
-	readonly id: string;
-	readonly schema: TSchema;
-	path?(): string;
-	load(): T | null;
-	invalidate?(): void;
-}
-
-export class ConfigError extends Error {
-	readonly #message: string;
-	constructor(
-		public readonly id: string,
-		public readonly schemaErrors: ErrorObject[] | null | undefined,
-		public readonly other?: { err: unknown; stage: string },
-	) {
-		let messages: string[] | undefined;
-		let cause: any | undefined;
-		let klass: string;
-
-		if (schemaErrors) {
-			klass = "Schema";
-			messages = schemaErrors.map(e => `${e.instancePath || "root"}: ${e.message}`);
-		} else if (other) {
-			klass = other.stage;
-			if (other.err instanceof Error) {
-				messages = [other.err.message];
-				cause = other.err;
-			} else {
-				messages = [String(other.err)];
-			}
-		} else {
-			klass = "Unknown";
-		}
-
-		const title = `Failed to load config file ${id}, ${klass} error:`;
-		let message: string;
-		switch (messages?.length ?? 0) {
-			case 0:
-				message = title.slice(0, -1);
-				break;
-			case 1:
-				message = `${title} ${messages![0]}`;
-				break;
-			default:
-				message = `${title}\n${messages!.map(m => `  - ${m}`).join("\n")}`;
-				break;
-		}
-
-		super(message, { cause });
-		this.name = "LoadError";
-		this.#message = message;
-	}
-
-	get message(): string {
-		return this.#message;
-	}
-
-	toString(): string {
-		return this.message;
-	}
-}
-
-export type LoadStatus = "ok" | "error" | "not-found";
-
-export type LoadResult<T> =
-	| { value?: null; error: ConfigError; status: "error" }
-	| { value: T; error?: undefined; status: "ok" }
-	| { value?: null; error?: unknown; status: "not-found" };
-
-export class ConfigFile<T> implements IConfigFile<T> {
-	readonly #basePath: string;
-	#cache?: LoadResult<T>;
-	#auxValidate?: (value: T) => void;
-
-	constructor(
-		readonly id: string,
-		readonly schema: TSchema,
-		configPath: string = path.join(getAgentDir(), `${id}.yml`),
-	) {
-		this.#basePath = configPath;
-		if (configPath.endsWith(".yml")) {
-			const jsonPath = `${configPath.slice(0, -4)}.json`;
-			migrateJsonToYml(jsonPath, configPath);
-		} else if (configPath.endsWith(".yaml")) {
-			const jsonPath = `${configPath.slice(0, -5)}.json`;
-			migrateJsonToYml(jsonPath, configPath);
-		} else if (configPath.endsWith(".json") || configPath.endsWith(".jsonc")) {
-			// JSON configs are still supported without migration.
-		} else {
-			throw new Error(`Invalid config file path: ${configPath}`);
-		}
-	}
-
-	relocate(path?: string): ConfigFile<T> {
-		if (!path || path === this.#basePath) return this;
-		const result = new ConfigFile<T>(this.id, this.schema, path);
-		result.#auxValidate = this.#auxValidate;
-		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) => {
-			prev?.(value);
-			try {
-				validate(value);
-			} catch (error) {
-				throw new ConfigError(this.id, undefined, { err: error, stage: `Validate(${name})` });
-			}
-		};
-		return this;
-	}
-
-	createDefault() {
-		return Value.Default(this.schema, [], undefined) as T;
-	}
-
-	#storeCache(result: LoadResult<T>): LoadResult<T> {
-		this.#cache = result;
-		return result;
-	}
-
-	tryLoad(): LoadResult<T> {
-		if (this.#cache) return this.#cache;
-
-		try {
-			const content = fs.readFileSync(this.path(), "utf-8").trim();
-
-			let parsed: unknown;
-			if (this.#basePath.endsWith(".json") || this.#basePath.endsWith(".jsonc")) {
-				parsed = JSONC.parse(content);
-			} else if (this.#basePath.endsWith(".yml") || this.#basePath.endsWith(".yaml")) {
-				parsed = YAML.parse(content);
-			} else {
-				throw new Error(`Invalid config file path: ${this.#basePath}`);
-			}
-
-			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 as T, status: "ok" });
-		} catch (error) {
-			if (isEnoent(error)) {
-				return this.#storeCache({ status: "not-found" });
-			}
-			logger.warn("Failed to parse config file", { path: this.path(), error });
-			return this.#storeCache({
-				error: new ConfigError(this.id, undefined, { err: error, stage: "Unexpected" }),
-				status: "error",
-			});
-		}
-	}
-
-	load(): T | null {
-		return this.tryLoad().value ?? null;
-	}
-
-	loadOrDefault(): T {
-		return this.tryLoad().value ?? this.createDefault();
-	}
-
-	path(): string {
-		return this.#basePath;
-	}
-
-	invalidate() {
-		this.#cache = undefined;
-	}
-}
-
 // =============================================================================
 // Multi-Config Directory Helpers
 // =============================================================================

package/src/discovery/claude-plugins.ts

@@ -31,6 +31,7 @@ const PRIORITY = 70; // Below claude.ts (80) so user .claude/ overrides win
 interface ClaudePluginManifest {
 	skills?: string;
 	"slash-commands"?: string;
+	commands?: string;
 }
 
 interface ResolvedPluginDir {
@@ -59,24 +60,35 @@ function isWithinPluginRoot(rootPath: string, targetPath: string): boolean {
 
 async function resolvePluginDir(
 	root: ClaudePluginRoot,
-	manifestKey: keyof ClaudePluginManifest,
+	manifestKeys: ReadonlyArray<keyof ClaudePluginManifest>,
 	fallback: string,
 ): Promise<ResolvedPluginDir> {
 	const manifest = await readPluginManifest(root);
 	const fallbackDir = path.join(root.path, fallback);
-	const configured = manifest?.[manifestKey];
-	if (typeof configured !== "string" || !configured.trim()) {
+
+	let configured: string | undefined;
+	let matchedKey: keyof ClaudePluginManifest | undefined;
+	for (const key of manifestKeys) {
+		const val = manifest?.[key];
+		if (typeof val === "string" && val.trim()) {
+			configured = val.trim();
+			matchedKey = key;
+			break;
+		}
+	}
+
+	if (configured === undefined) {
 		return { dir: fallbackDir };
 	}
 
-	const resolved = path.resolve(root.path, configured.trim());
+	const resolved = path.resolve(root.path, configured);
 	if (isWithinPluginRoot(root.path, resolved)) {
 		return { dir: resolved };
 	}
 
 	return {
 		dir: fallbackDir,
-		warning: `[claude-plugins] Ignoring ${String(manifestKey)} path outside plugin root for ${root.id}: ${configured}`,
+		warning: `[claude-plugins] Ignoring ${String(matchedKey)} path outside plugin root for ${root.id}: ${configured}`,
 	};
 }
 
@@ -93,7 +105,7 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 
 	const results = await Promise.all(
 		roots.map(async root => {
-			const { dir: skillsDir, warning } = await resolvePluginDir(root, "skills", "skills");
+			const { dir: skillsDir, warning } = await resolvePluginDir(root, ["skills"], "skills");
 			const result = await scanSkillsFromDir(ctx, {
 				dir: skillsDir,
 				providerId: PROVIDER_ID,
@@ -128,7 +140,7 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 
 	const results = await Promise.all(
 		roots.map(async root => {
-			const { dir: commandsDir, warning } = await resolvePluginDir(root, "slash-commands", "commands");
+			const { dir: commandsDir, warning } = await resolvePluginDir(root, ["commands", "slash-commands"], "commands");
 			const result = await loadFilesFromDir<SlashCommand>(ctx, commandsDir, PROVIDER_ID, root.scope, {
 				extensions: ["md"],
 				transform: (name, content, filePath, source) => {

package/src/edit/renderer.ts

@@ -340,7 +340,13 @@ function normalizeHashlineInputPreviewPath(rawPath: string): string {
 
 function parseHashlineInputPreviewHeader(line: string): string | null {
 	if (!line.startsWith(HL_INPUT_HEADER_PREFIX)) return null;
-	const body = line.slice(HL_INPUT_HEADER_PREFIX.length).trim();
+	// The real parser (`parseHashlineHeaderLine` in `hashline/input.ts`) strips
+	// every leading "@" before resolving the path so canonical "@@ PATH" headers
+	// (and stray "@ PATH" / "@@@ PATH" runs) all route to the same file. Mirror
+	// that here so the renderer doesn't surface a literal "@ " in the title.
+	let prefixEnd = 0;
+	while (prefixEnd < line.length && line[prefixEnd] === HL_INPUT_HEADER_PREFIX) prefixEnd++;
+	const body = line.slice(prefixEnd).trim();
 	const previewPath = normalizeHashlineInputPreviewPath(body);
 	return previewPath.length > 0 ? previewPath : null;
 }

package/src/eval/js/executor.ts

@@ -1,5 +1,6 @@
 import { DEFAULT_MAX_BYTES, OutputSink } from "../../session/streaming-output";
 import type { ToolSession } from "../../tools";
+import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../../tools/output-meta";
 import { executeInVmContext, type JsDisplayOutput } from "./context-manager";
 
 export interface JsExecutorOptions {
@@ -49,6 +50,8 @@ export async function executeJs(code: string, options: JsExecutorOptions): Promi
 		artifactPath: options.artifactPath,
 		artifactId: options.artifactId,
 		spillThreshold: DEFAULT_MAX_BYTES,
+		headBytes: resolveOutputSinkHeadBytes(options.session.settings),
+		maxColumns: resolveOutputMaxColumns(options.session.settings),
 		onChunk: chunk => options.onChunk?.(chunk),
 	});
 	const timeoutMs = getExecutionTimeoutMs(options);

package/src/eval/js/shared/rewrite-imports.ts

@@ -180,7 +180,7 @@ export function rewriteImports(code: string): string {
  * Nested declarations (inside functions, blocks, classes) are left alone \u2014 they're
  * scoped to their enclosing function/block regardless of `var` vs `let`/`const`.
  */
-export function demoteTopLevelLexicals(code: string): string {
+function demoteTopLevelLexicals(code: string): string {
 	if (!/\b(?:const|let|class)\b/.test(code)) return code;
 
 	const ast = parseProgram(code);
@@ -248,7 +248,7 @@ function returnFinalExpression(code: string): { source: string; returned: boolea
  * common case avoids an extra transpile pass. We detect "looks like TS" with a cheap regex
  * before invoking the transpiler.
  */
-export function stripTypeScript(code: string): string {
+function stripTypeScript(code: string): string {
 	if (!LOOKS_LIKE_TS.test(code)) return code;
 	try {
 		return new Bun.Transpiler({ loader: "ts" }).transformSync(code);

package/src/eval/py/executor.ts

@@ -1,6 +1,8 @@
 import { getProjectDir, logger } from "@oh-my-pi/pi-utils";
+import { Settings } from "../../config/settings";
 import { OutputSink } from "../../session/streaming-output";
 import type { ToolSession } from "../../tools";
+import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../../tools/output-meta";
 import type { JsStatusEvent } from "../js/shared/types";
 import type { KernelDisplayOutput } from "./display";
 import {
@@ -815,10 +817,13 @@ async function executeWithKernel(
 	code: string,
 	options: PythonExecutorOptions | undefined,
 ): Promise<PythonResult> {
+	const settings = await Settings.init();
 	const sink = new OutputSink({
 		onChunk: options?.onChunk,
 		artifactPath: options?.artifactPath,
 		artifactId: options?.artifactId,
+		headBytes: resolveOutputSinkHeadBytes(settings),
+		maxColumns: resolveOutputMaxColumns(settings),
 	});
 	const displayOutputs: KernelDisplayOutput[] = [];
 	const deadlineMs = getExecutionDeadlineMs(options);

package/src/eval/py/runner.py

@@ -25,9 +25,11 @@ when installed.
 
 from __future__ import annotations
 
+import asyncio
 import ast
 import base64
 import builtins
+import inspect
 import io
 import json
 import os
@@ -120,6 +122,7 @@ class _RunnerState:
             "__builtins__": builtins,
         }
         self.last_install_marker: int = 0
+        self.loop: asyncio.AbstractEventLoop | None = None
 
 
 _STATE = _RunnerState()
@@ -688,13 +691,41 @@ _install_builtins(_STATE.user_ns)
 # ---------------------------------------------------------------------------
 
 
+_TLA_FLAG = getattr(ast, "PyCF_ALLOW_TOP_LEVEL_AWAIT", 0x2000)
+
+
+def _get_event_loop() -> asyncio.AbstractEventLoop:
+    loop = _STATE.loop
+    if loop is None or loop.is_closed():
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        _STATE.loop = loop
+    return loop
+
+
+def _run_compiled(code, ns: dict, *, want_value: bool) -> Any:
+    """Execute a code object, awaiting it if compiled as a coroutine.
+
+    ``want_value`` is True for the trailing expression — we return ``eval``'s
+    result (or the awaited coroutine's value). For statement blocks the
+    return is always ``None``.
+    """
+    if code.co_flags & inspect.CO_COROUTINE:
+        coro = eval(code, ns)
+        result = _get_event_loop().run_until_complete(coro)
+        return result if want_value else None
+    if want_value:
+        return eval(code, ns)
+    exec(code, ns)
+    return None
+
+
 def _exec_source(source: str, ns: dict) -> None:
     """Compile + execute ``source``; if the last node is an expression, route
-    its value through ``__omp_display`` so dataframes/figures render rich."""
-    try:
-        module = ast.parse(source, mode="exec")
-    except SyntaxError:
-        raise
+    its value through ``__omp_display`` so dataframes/figures render rich.
+    Top-level ``await`` / ``async for`` / ``async with`` is permitted; the
+    cell is driven through the runner's persistent event loop."""
+    module = ast.parse(source, mode="exec")
 
     if not module.body:
         return
@@ -704,16 +735,16 @@ def _exec_source(source: str, ns: dict) -> None:
         body_module = ast.Module(body=module.body[:-1], type_ignores=[])
         expr_module = ast.Expression(body=last.value)
         ast.copy_location(expr_module, last)
-        body_code = compile(body_module, "<cell>", "exec")
-        expr_code = compile(expr_module, "<cell>", "eval")
-        exec(body_code, ns)
-        value = eval(expr_code, ns)
+        body_code = compile(body_module, "<cell>", "exec", flags=_TLA_FLAG)
+        expr_code = compile(expr_module, "<cell>", "eval", flags=_TLA_FLAG)
+        _run_compiled(body_code, ns, want_value=False)
+        value = _run_compiled(expr_code, ns, want_value=True)
         if value is not None:
             __omp_display(value, kind="result")
         return
 
-    code = compile(module, "<cell>", "exec")
-    exec(code, ns)
+    code = compile(module, "<cell>", "exec", flags=_TLA_FLAG)
+    _run_compiled(code, ns, want_value=False)
 
 
 # ---------------------------------------------------------------------------

package/src/eval/py/runtime.ts

@@ -151,6 +151,7 @@ export function filterEnv(env: Record<string, string | undefined>): Record<strin
  */
 export function resolveVenvPath(cwd: string): string | undefined {
 	if ($env.VIRTUAL_ENV) return $env.VIRTUAL_ENV;
+	if ($env.CONDA_PREFIX) return $env.CONDA_PREFIX;
 	const candidates = [path.join(cwd, ".venv"), path.join(cwd, "venv")];
 	for (const candidate of candidates) {
 		if (fs.existsSync(candidate)) {

package/src/exa/factory.ts

@@ -3,7 +3,7 @@
  */
 import type { TObject, TProperties } from "@sinclair/typebox";
 import type { CustomTool } from "../extensibility/custom-tools/types";
-import { callExaTool, findApiKey, formatSearchResults, isSearchResponse } from "./mcp-client";
+import { callExaTool, findApiKey, formatGenericResponse, formatSearchResults, isSearchResponse } from "./mcp-client";
 import type { ExaRenderDetails } from "./types";
 
 /** Creates an Exa tool with standardized API key handling, error wrapping, and optional search response formatting. */
@@ -44,7 +44,7 @@ export function createExaTool(
 				}
 
 				return {
-					content: [{ type: "text" as const, text: JSON.stringify(response, null, 2) }],
+					content: [{ type: "text" as const, text: formatGenericResponse(response) }],
 					details: { raw: response, toolName: name },
 				};
 			} catch (error) {

package/src/exa/mcp-client.ts

@@ -174,6 +174,79 @@ export function formatSearchResults(data: ExaSearchResponse): string {
 
 	return output.trim();
 }
+/**
+ * Format a non-search MCP response as human-readable text.
+ * Handles objects, arrays, primitives, and common MCP response shapes.
+ */
+export function formatGenericResponse(data: unknown): string {
+	if (data === null || data === undefined) return "No result.";
+	if (typeof data === "string") return data;
+	if (typeof data === "number" || typeof data === "boolean") return String(data);
+
+	if (Array.isArray(data)) {
+		if (data.length === 0) return "(empty)";
+		const parts: string[] = [];
+		for (let i = 0; i < data.length; i++) {
+			const item = data[i];
+			if (typeof item === "object" && item !== null) {
+				const record = item as Record<string, unknown>;
+				const title = (record.title ?? record.name ?? record.id ?? `Item ${i + 1}`) as string;
+				parts.push(`\n### ${title}`);
+				for (const [k, v] of Object.entries(record)) {
+					if (["title", "name", "id"].includes(k)) continue;
+					parts.push(`- **${k}:** ${formatValue(v)}`);
+				}
+			} else {
+				parts.push(`- ${formatValue(item)}`);
+			}
+		}
+		return parts.join("\n");
+	}
+
+	if (typeof data === "object") {
+		const record = data as Record<string, unknown>;
+		if (record.content && Array.isArray(record.content)) {
+			// MCP-style content array — extract text blocks
+			const texts = record.content
+				.filter(
+					(c: unknown): c is { type: string; text?: string } =>
+						typeof c === "object" && c !== null && (c as Record<string, unknown>)?.type === "text",
+				)
+				.map(c => c.text ?? "")
+				.filter(Boolean);
+			if (texts.length > 0) return texts.join("\n");
+		}
+
+		const lines: string[] = [];
+		for (const [k, v] of Object.entries(record)) {
+			if (k === "content") continue; // handled above
+			if (v === null || v === undefined) continue;
+			if (typeof v === "object") {
+				const formatted = formatGenericResponse(v);
+				if (formatted) lines.push(`- **${k}:**\n${indent(formatted, 2)}`);
+			} else {
+				lines.push(`- **${k}:** ${formatValue(v)}`);
+			}
+		}
+		return lines.join("\n") || "(empty)";
+	}
+
+	return String(data);
+}
+
+function formatValue(v: unknown): string {
+	if (v === null || v === undefined) return "—";
+	if (typeof v === "object") return JSON.stringify(v);
+	return String(v);
+}
+
+function indent(text: string, spaces: number): string {
+	const pad = " ".repeat(spaces);
+	return text
+		.split("\n")
+		.map(line => pad + line)
+		.join("\n");
+}
 
 /** Check if result is a search response */
 export function isSearchResponse(data: unknown): data is ExaSearchResponse {
@@ -260,7 +333,7 @@ export class MCPWrappedTool implements CustomTool<TSchema, ExaRenderDetails> {
 			}
 
 			return {
-				content: [{ type: "text" as const, text: JSON.stringify(response, null, 2) }],
+				content: [{ type: "text" as const, text: formatGenericResponse(response) }],
 				details: { raw: response, toolName: this.config.name },
 			};
 		} catch (error) {

package/src/exec/bash-executor.ts

@@ -7,6 +7,7 @@ import * as fs from "node:fs/promises";
 import { executeShell, type MinimizerOptions, Shell } from "@oh-my-pi/pi-natives";
 import { Settings, type ShellMinimizerSettings } from "../config/settings";
 import { OutputSink } from "../session/streaming-output";
+import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../tools/output-meta";
 import { getOrCreateSnapshot } from "../utils/shell-snapshot";
 import { NON_INTERACTIVE_ENV } from "./non-interactive-env";
 
@@ -64,7 +65,8 @@ async function resolveShellCwd(cwd: string | undefined): Promise<string | undefi
 	}
 }
 
-function buildMinimizerOptions(group: ShellMinimizerSettings): MinimizerOptions | undefined {
+/** Translate `ShellMinimizerSettings` into native `MinimizerOptions`, or `undefined` when disabled. */
+export function buildMinimizerOptions(group: ShellMinimizerSettings): MinimizerOptions | undefined {
 	if (!group.enabled) return undefined;
 	return {
 		enabled: true,
@@ -94,6 +96,8 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		onChunk: options?.onChunk,
 		artifactPath: options?.artifactPath,
 		artifactId: options?.artifactId,
+		headBytes: resolveOutputSinkHeadBytes(settings),
+		maxColumns: resolveOutputMaxColumns(settings),
 		// Throttle the streaming preview callback to avoid saturating the
 		// event loop when commands produce massive output (e.g. seq 1 50M).
 		chunkThrottleMs: options?.onChunk ? 50 : 0,