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

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [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.0.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.0.0",
+		"@oh-my-pi/pi-agent-core": "10.0.0",
+		"@oh-my-pi/pi-ai": "10.0.0",
+		"@oh-my-pi/pi-natives": "10.0.0",
+		"@oh-my-pi/pi-tui": "10.0.0",
+		"@oh-my-pi/pi-utils": "10.0.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/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/tools/find.ts

@@ -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,6 +237,17 @@ 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}`);
 			}