@oh-my-pi/pi-coding-agent 9.8.0 → 10.2.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [10.1.0] - 2026-02-01
+### Added
+
+- Added work scheduling profiler to debug menu for analyzing CPU scheduling patterns over the last 30 seconds
+- Added support for work profile data in report bundles including folded stacks, summary, and flamegraph visualization
+
+## [10.0.0] - 2026-02-01
+### Added
+
+- Added `shell` subcommand for interactive shell console testing with brush-core
+- Added `--cwd` / `-C` option to set working directory for shell commands
+- Added `--timeout` / `-t` option to configure per-command timeout in milliseconds
+- Added `--no-snapshot` option to skip sourcing snapshot from user shell
+
+### Fixed
+
+- `find` now returns a single match when given a file path instead of failing with "not a directory"
+
 ## [9.8.0] - 2026-02-01
 ### Breaking Changes
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "9.8.0",
+	"version": "10.2.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -79,12 +79,12 @@
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@oh-my-pi/omp-stats": "9.8.0",
-		"@oh-my-pi/pi-agent-core": "9.8.0",
-		"@oh-my-pi/pi-ai": "9.8.0",
-		"@oh-my-pi/pi-natives": "9.8.0",
-		"@oh-my-pi/pi-tui": "9.8.0",
-		"@oh-my-pi/pi-utils": "9.8.0",
+		"@oh-my-pi/omp-stats": "10.2.0",
+		"@oh-my-pi/pi-agent-core": "10.2.0",
+		"@oh-my-pi/pi-ai": "10.2.0",
+		"@oh-my-pi/pi-natives": "10.2.0",
+		"@oh-my-pi/pi-tui": "10.2.0",
+		"@oh-my-pi/pi-utils": "10.2.0",
 		"@openai/agents": "^0.4.4",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",

package/src/cli/args.ts

@@ -191,6 +191,7 @@ ${chalk.bold("Subcommands:")}
   update    Check for and install updates
   config    Manage configuration settings
   setup     Install dependencies for optional features
+  shell     Interactive shell console (brush-core test)
 
 ${chalk.bold("Options:")}
   --model <pattern>              Model to use (fuzzy match: "opus", "gpt-5.2", or "p-openai/gpt-5.2")

package/src/cli/shell-cli.ts

@@ -0,0 +1,174 @@
+/**
+ * Shell CLI command handlers.
+ *
+ * Handles `omp shell` subcommand for testing the native brush-core shell.
+ */
+import * as path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { Shell } from "@oh-my-pi/pi-natives";
+import chalk from "chalk";
+import { APP_NAME } from "../config";
+import { Settings } from "../config/settings";
+import { getOrCreateSnapshot } from "../utils/shell-snapshot";
+
+export interface ShellCommandArgs {
+	cwd?: string;
+	timeoutMs?: number;
+	noSnapshot?: boolean;
+}
+
+export function parseShellArgs(args: string[]): ShellCommandArgs | undefined {
+	if (args.length === 0 || args[0] !== "shell") {
+		return undefined;
+	}
+
+	const result: ShellCommandArgs = {};
+
+	for (let i = 1; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--cwd" || arg === "-C") {
+			result.cwd = args[++i];
+		} else if (arg === "--timeout" || arg === "-t") {
+			const parsed = Number.parseInt(args[++i], 10);
+			if (Number.isFinite(parsed)) {
+				result.timeoutMs = parsed;
+			}
+		} else if (arg === "--no-snapshot") {
+			result.noSnapshot = true;
+		}
+	}
+
+	return result;
+}
+
+export async function runShellCommand(cmd: ShellCommandArgs): Promise<void> {
+	if (!process.stdin.isTTY) {
+		process.stderr.write("Error: shell console requires an interactive TTY.\n");
+		process.exit(1);
+	}
+
+	const cwd = cmd.cwd ? path.resolve(cmd.cwd) : process.cwd();
+	const settings = await Settings.init({ cwd });
+	const { shell, env: shellEnv } = settings.getShellConfig();
+	const snapshotPath = cmd.noSnapshot || !shell.includes("bash") ? null : await getOrCreateSnapshot(shell, shellEnv);
+	const shellSession = new Shell({ sessionEnv: shellEnv, snapshotPath: snapshotPath ?? undefined });
+
+	let active = false;
+	let lastChar: string | null = null;
+
+	const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+	const prompt = chalk.cyan(`${APP_NAME} shell> `);
+
+	const printHelp = () => {
+		process.stdout.write(
+			`${chalk.bold("Shell Console Commands")}
+
+` +
+				`${chalk.bold("Special Commands:")}
+  .help           Show this help
+  .exit, exit     Exit the console
+
+` +
+				`${chalk.bold("Options:")}
+  --cwd, -C <path>     Set working directory for commands
+  --timeout, -t <ms>   Timeout per command in milliseconds
+  --no-snapshot        Skip sourcing snapshot from user shell
+
+` +
+				`${chalk.bold("Notes:")}
+  Runs in a persistent brush-core shell session.
+  Variables and functions defined in one command persist for the next.
+
+`,
+		);
+	};
+
+	const interruptHandler = () => {
+		if (active) {
+			shellSession.abort();
+			return;
+		}
+		rl.close();
+		process.exit(0);
+	};
+
+	process.on("SIGINT", interruptHandler);
+	process.stdout.write(chalk.dim("Type .help for commands.\n"));
+
+	try {
+		while (true) {
+			const line = (await rl.question(prompt)).trim();
+			if (!line) {
+				continue;
+			}
+			if (line === ".help") {
+				printHelp();
+				continue;
+			}
+			if (line === ".exit" || line === "exit" || line === "quit") {
+				break;
+			}
+
+			active = true;
+			lastChar = null;
+			try {
+				const result = await shellSession.run(
+					{
+						command: line,
+						cwd,
+						timeoutMs: cmd.timeoutMs,
+					},
+					(err, chunk) => {
+						if (err) {
+							process.stderr.write(`${err.message}\n`);
+							return;
+						}
+						if (chunk.length > 0) {
+							lastChar = chunk[chunk.length - 1] ?? null;
+						}
+						process.stdout.write(chunk);
+					},
+				);
+
+				if (lastChar && lastChar !== "\n") {
+					process.stdout.write("\n");
+				}
+
+				if (result.timedOut) {
+					process.stderr.write(chalk.yellow("Command timed out.\n"));
+				} else if (result.cancelled) {
+					process.stderr.write(chalk.yellow("Command cancelled.\n"));
+				} else if (result.exitCode !== 0 && result.exitCode !== undefined) {
+					process.stderr.write(chalk.yellow(`Exit code: ${result.exitCode}\n`));
+				}
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				process.stderr.write(chalk.red(`Error: ${message}\n`));
+			} finally {
+				active = false;
+			}
+		}
+	} finally {
+		process.off("SIGINT", interruptHandler);
+		rl.close();
+	}
+}
+
+export function printShellHelp(): void {
+	process.stdout.write(`${chalk.bold(`${APP_NAME} shell`)} - Interactive shell console for testing
+
+${chalk.bold("Usage:")}
+  ${APP_NAME} shell [options]
+
+${chalk.bold("Options:")}
+  --cwd, -C <path>     Set working directory for commands
+  --timeout, -t <ms>   Timeout per command in milliseconds
+  --no-snapshot        Skip sourcing snapshot from user shell
+  -h, --help           Show this help
+
+${chalk.bold("Examples:")}
+  ${APP_NAME} shell
+  ${APP_NAME} shell --cwd ./tmp
+  ${APP_NAME} shell --timeout 2000
+`);
+}

package/src/debug/index.ts

@@ -4,6 +4,7 @@
  * Provides tools for debugging, bug report generation, and system diagnostics.
  */
 import * as fs from "node:fs/promises";
+import { getWorkProfile } from "@oh-my-pi/pi-natives/work";
 import { Container, Loader, type SelectItem, SelectList, Spacer, Text } from "@oh-my-pi/pi-tui";
 import { getSessionsDir } from "../config";
 import { DynamicBorder } from "../modes/components/dynamic-border";
@@ -17,6 +18,7 @@ import { collectSystemInfo, formatSystemInfo } from "./system-info";
 const DEBUG_MENU_ITEMS: SelectItem[] = [
 	{ value: "open-artifacts", label: "Open: artifact folder", description: "Open session artifacts in file manager" },
 	{ value: "performance", label: "Report: performance issue", description: "Profile CPU, reproduce, then bundle" },
+	{ value: "work", label: "Profile: work scheduling", description: "Open flamegraph of last 30s" },
 	{ value: "dump", label: "Report: dump session", description: "Create report bundle immediately" },
 	{ value: "memory", label: "Report: memory issue", description: "Heap snapshot + bundle" },
 	{ value: "logs", label: "View: recent logs", description: "Show last 50 log entries" },
@@ -69,6 +71,9 @@ export class DebugSelectorComponent extends Container {
 			case "performance":
 				await this.handlePerformanceReport();
 				break;
+			case "work":
+				await this.handleWorkReport();
+				break;
 			case "dump":
 				await this.handleDumpReport();
 				break;
@@ -138,10 +143,12 @@ export class DebugSelectorComponent extends Container {
 
 		try {
 			const cpuProfile = await session.stop();
+			const workProfile = getWorkProfile(30);
 			const result = await createReportBundle({
 				sessionFile: this.ctx.sessionManager.getSessionFile(),
 				settings: this.getResolvedSettings(),
 				cpuProfile,
+				workProfile,
 			});
 
 			loader.stop();
@@ -162,6 +169,39 @@ export class DebugSelectorComponent extends Container {
 		this.ctx.ui.requestRender();
 	}
 
+	private async handleWorkReport(): Promise<void> {
+		try {
+			const workProfile = getWorkProfile(30);
+
+			if (!workProfile.svg) {
+				this.ctx.showWarning(`No work profile data (${workProfile.sampleCount} samples)`);
+				return;
+			}
+
+			// Write SVG to temp file and open in browser
+			const tmpPath = `/tmp/work-profile-${Date.now()}.svg`;
+			await Bun.write(tmpPath, workProfile.svg);
+
+			const openCmd =
+				process.platform === "darwin"
+					? ["open", tmpPath]
+					: process.platform === "win32"
+						? ["cmd", "/c", "start", "", tmpPath]
+						: ["xdg-open", tmpPath];
+
+			Bun.spawn(openCmd, { stdout: "ignore", stderr: "ignore" }).unref();
+
+			this.ctx.chatContainer.addChild(new Spacer(1));
+			this.ctx.chatContainer.addChild(
+				new Text(theme.fg("dim", `Opened flamegraph (${workProfile.sampleCount} samples)`), 1, 0),
+			);
+		} catch (err) {
+			this.ctx.showError(`Failed to open profile: ${err instanceof Error ? err.message : String(err)}`);
+		}
+
+		this.ctx.ui.requestRender();
+	}
+
 	private async handleDumpReport(): Promise<void> {
 		const loader = new Loader(
 			this.ctx.ui,

package/src/debug/report-bundle.ts

@@ -6,6 +6,7 @@
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
+import type { WorkProfile } from "@oh-my-pi/pi-natives/work";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import type { CpuProfile, HeapSnapshot } from "./profiler";
 import { collectSystemInfo, sanitizeEnv } from "./system-info";
@@ -42,6 +43,8 @@ export interface ReportBundleOptions {
 	cpuProfile?: CpuProfile;
 	/** Heap snapshot (for memory reports) */
 	heapSnapshot?: HeapSnapshot;
+	/** Work profile (for work scheduling reports) */
+	workProfile?: WorkProfile;
 }
 
 export interface ReportBundleResult {
@@ -63,6 +66,9 @@ export interface ReportBundleResult {
  * - profile.cpuprofile: CPU profile (performance report only)
  * - profile.md: Markdown CPU profile (performance report only)
  * - heap.heapsnapshot: Heap snapshot (memory report only)
+ * - work.folded: Work profile folded stacks (work report only)
+ * - work.md: Work profile summary (work report only)
+ * - work.svg: Work profile flamegraph (work report only)
  */
 export async function createReportBundle(options: ReportBundleOptions): Promise<ReportBundleResult> {
 	const reportsDir = getReportsDir();
@@ -131,6 +137,18 @@ export async function createReportBundle(options: ReportBundleOptions): Promise<
 		files.push("heap.heapsnapshot");
 	}
 
+	// Work profile
+	if (options.workProfile) {
+		data["work.folded"] = options.workProfile.folded;
+		files.push("work.folded");
+		data["work.md"] = options.workProfile.summary;
+		files.push("work.md");
+		if (options.workProfile.svg) {
+			data["work.svg"] = options.workProfile.svg;
+			files.push("work.svg");
+		}
+	}
+
 	// Write archive
 	await Bun.Archive.write(outputPath, data, { compress: "gzip" });
 

package/src/exec/bash-executor.ts

@@ -65,8 +65,6 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		};
 	}
 
-	let abortListener: (() => void) | undefined;
-
 	try {
 		const sessionKey = buildSessionKey(shell, prefix, snapshotPath, shellEnv, options?.sessionKey);
 		let shellSession = shellSessions.get(sessionKey);
@@ -75,19 +73,13 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 			shellSessions.set(sessionKey, shellSession);
 		}
 
-		if (options?.signal) {
-			abortListener = () => {
-				shellSession?.abort();
-			};
-			options.signal.addEventListener("abort", abortListener, { once: true });
-		}
-
 		const result = await shellSession.run(
 			{
 				command: finalCommand,
 				cwd: options?.cwd,
 				env: options?.env,
 				timeoutMs: options?.timeout,
+				signal: options?.signal,
 			},
 			(err, chunk) => {
 				if (!err) {
@@ -127,9 +119,6 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		};
 	} finally {
 		await pendingChunks;
-		if (options?.signal && abortListener) {
-			options.signal.removeEventListener("abort", abortListener);
-		}
 	}
 }
 

package/src/main.ts

@@ -20,6 +20,7 @@ import { listModels } from "./cli/list-models";
 import { parsePluginArgs, printPluginHelp, runPluginCommand } from "./cli/plugin-cli";
 import { selectSession } from "./cli/session-picker";
 import { parseSetupArgs, printSetupHelp, runSetupCommand } from "./cli/setup-cli";
+import { parseShellArgs, printShellHelp, runShellCommand } from "./cli/shell-cli";
 import { parseStatsArgs, printStatsHelp, runStatsCommand } from "./cli/stats-cli";
 import { parseUpdateArgs, printUpdateHelp, runUpdateCommand } from "./cli/update-cli";
 import { runCommitCommand } from "./commit";
@@ -558,6 +559,17 @@ export async function main(args: string[]) {
 		return;
 	}
 
+	// Handle shell subcommand (for testing brush-core shell)
+	const shellCmd = parseShellArgs(args);
+	if (shellCmd) {
+		if (args.includes("--help") || args.includes("-h")) {
+			printShellHelp();
+			return;
+		}
+		await runShellCommand(shellCmd);
+		return;
+	}
+
 	// Handle commit subcommand
 	const commitCmd = parseCommitArgs(args);
 	if (commitCmd) {

package/src/system-prompt.ts

@@ -4,7 +4,7 @@
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
-import { getSystemInfo as getNativeSystemInfo, type SystemInfo, find as wasmFind } from "@oh-my-pi/pi-natives";
+import { FileType, getSystemInfo as getNativeSystemInfo, glob, type SystemInfo } from "@oh-my-pi/pi-natives";
 import { untilAborted } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import chalk from "chalk";
@@ -184,10 +184,10 @@ async function scanProjectTreeWithGlob(root: string): Promise<ProjectTreeScan |
 	const timeoutSignal = AbortSignal.timeout(GLOB_TIMEOUT_MS);
 	try {
 		const result = await untilAborted(timeoutSignal, () =>
-			wasmFind({
+			glob({
 				pattern: "**/*",
 				path: root,
-				fileType: "file",
+				fileType: FileType.File,
 			}),
 		);
 		entries = result.matches.map(match => match.path).filter(entry => entry.length > 0);

package/src/tools/find.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { type FindMatch, find as wasmFind } from "@oh-my-pi/pi-natives";
+import { FileType, type GlobMatch, glob } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { isEnoent, untilAborted } from "@oh-my-pi/pi-utils";
@@ -75,6 +75,11 @@ function parsePatternPath(pattern: string): { basePath: string; globPattern: str
 	return { basePath, globPattern };
 }
 
+function hasGlobChars(pattern: string): boolean {
+	const globChars = ["*", "?", "[", "{"];
+	return globChars.some(char => pattern.includes(char));
+}
+
 export interface FindToolDetails {
 	truncation?: TruncationResult;
 	resultLimitReached?: number;
@@ -94,6 +99,10 @@ export interface FindToolDetails {
 export interface FindOperations {
 	/** Check if path exists */
 	exists: (absolutePath: string) => Promise<boolean> | boolean;
+	/** Optional stat for distinguishing files vs directories. */
+	stat?: (
+		absolutePath: string,
+	) => Promise<{ isFile(): boolean; isDirectory(): boolean }> | { isFile(): boolean; isDirectory(): boolean };
 	/** Find files matching glob pattern. Returns relative paths. */
 	glob: (pattern: string, cwd: string, options: { ignore: string[]; limit: number }) => Promise<string[]> | string[];
 }
@@ -136,6 +145,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				throw new ToolError("Pattern must not be empty");
 			}
 
+			const hasGlob = hasGlobChars(normalizedPattern);
 			const { basePath, globPattern } = parsePatternPath(normalizedPattern);
 			const searchPath = resolveToCwd(basePath, this.session.cwd);
 
@@ -161,6 +171,20 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					throw new ToolError(`Path not found: ${searchPath}`);
 				}
 
+				if (!hasGlob && this.customOps.stat) {
+					const stat = await this.customOps.stat(searchPath);
+					if (stat.isFile()) {
+						const files = [scopePath];
+						const details: FindToolDetails = {
+							scopePath,
+							fileCount: 1,
+							files,
+							truncated: false,
+						};
+						return toolResult(details).text(files.join("\n")).done();
+					}
+				}
+
 				const results = await this.customOps.glob(globPattern, searchPath, {
 					ignore: ["**/node_modules/**", "**/.git/**"],
 					limit: effectiveLimit,
@@ -213,11 +237,22 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				}
 				throw err;
 			}
+
+			if (!hasGlob && searchStat.isFile()) {
+				const files = [scopePath];
+				const details: FindToolDetails = {
+					scopePath,
+					fileCount: 1,
+					files,
+					truncated: false,
+				};
+				return toolResult(details).text(files.join("\n")).done();
+			}
 			if (!searchStat.isDirectory()) {
 				throw new ToolError(`Path is not a directory: ${searchPath}`);
 			}
 
-			let matches: Awaited<ReturnType<typeof wasmFind>>["matches"];
+			let matches: Awaited<ReturnType<typeof glob>>["matches"];
 			const onUpdateMatches: string[] = [];
 			const updateIntervalMs = 200;
 			let lastUpdate = 0;
@@ -238,11 +273,11 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				});
 			};
 			const onMatch = onUpdate
-				? (match: FindMatch | null) => {
+				? (match: GlobMatch | null) => {
 						if (signal?.aborted || !match) return;
 						let relativePath = match.path;
 						if (!relativePath) return;
-						if (match.fileType === "dir" && !relativePath.endsWith("/")) {
+						if (match.fileType === FileType.Dir && !relativePath.endsWith("/")) {
 							relativePath += "/";
 						}
 						onUpdateMatches.push(relativePath);
@@ -253,11 +288,11 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
 			try {
 				const result = await untilAborted(combinedSignal, () =>
-					wasmFind(
+					glob(
 						{
 							pattern: globPattern,
 							path: searchPath,
-							fileType: "file",
+							fileType: FileType.File,
 							hidden: includeHidden,
 							maxResults: effectiveLimit,
 							sortByMtime: true,
@@ -293,7 +328,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				const hadTrailingSlash = line.endsWith("/") || line.endsWith("\\");
 				let relativePath = line;
 
-				const isDirectory = match.fileType === "dir";
+				const isDirectory = match.fileType === FileType.Dir;
 
 				if ((isDirectory || hadTrailingSlash) && !relativePath.endsWith("/")) {
 					relativePath += "/";

package/src/tools/read.ts

@@ -3,7 +3,7 @@ import * as os from "node:os";
 import path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
-import { find as wasmFind } from "@oh-my-pi/pi-natives";
+import { FileType, glob } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { ptree, untilAborted } from "@oh-my-pi/pi-utils";
@@ -361,10 +361,10 @@ async function listCandidateFiles(
 	const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
 	try {
 		const result = await untilAborted(combinedSignal, () =>
-			wasmFind({
+			glob({
 				pattern: "**/*",
 				path: searchRoot,
-				fileType: "file",
+				fileType: FileType.File,
 				hidden: true,
 			}),
 		);