@wahack/pi-coding-agent 15.11.0

package/src/commands/dry-balance.ts

@@ -0,0 +1,43 @@
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { runDryBalanceCommand } from "../cli/dry-balance-cli";
+
+export default class DryBalance extends Command {
+	static description = "Dry-run OAuth account balancing across random session ids";
+
+	static args = {
+		model: Args.string({
+			description: "Model selector (provider/model or fuzzy id). Defaults to the configured default model.",
+			required: false,
+		}),
+	};
+
+	static flags = {
+		model: Flags.string({ description: "Model selector (same syntax as --model on omp)" }),
+		count: Flags.integer({ description: "Number of random session ids to try", default: 100 }),
+		concurrency: Flags.integer({ description: "Maximum concurrent credential resolutions", default: 32 }),
+		json: Flags.boolean({ description: "Output JSON" }),
+		bench: Flags.boolean({ description: "Send one live benchmark request per OAuth account" }),
+	};
+
+	static examples = [
+		"# Dry-run the configured default model with 100 random session ids\n  omp dry-balance",
+		"# Dry-run a specific model\n  omp dry-balance anthropic/claude-sonnet-4-5",
+		"# Larger run with bounded concurrency\n  omp dry-balance --model openai-codex/gpt-5-codex --count 1000 --concurrency 64",
+		"# Benchmark every OAuth account in parallel\n  omp dry-balance --bench",
+		"# Machine-readable output\n  omp dry-balance --json",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(DryBalance);
+		await runDryBalanceCommand({
+			model: args.model,
+			flags: {
+				model: flags.model,
+				count: flags.count,
+				concurrency: flags.concurrency,
+				json: flags.json,
+				bench: flags.bench,
+			},
+		});
+	}
+}

package/src/commands/gallery.ts

@@ -0,0 +1,52 @@
+/**
+ * Render every built-in tool's renderer across its lifecycle states.
+ */
+import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { GALLERY_STATES, type GalleryState, runGalleryCommand } from "../cli/gallery-cli";
+
+export default class Gallery extends Command {
+	static description = "Preview tool renderers across streaming, in-progress, success, and failure states";
+
+	static flags = {
+		tool: Flags.string({ char: "t", description: "Render a single tool by name" }),
+		state: Flags.string({
+			char: "s",
+			description: "Render only the given lifecycle state(s)",
+			options: [...GALLERY_STATES],
+			multiple: true,
+		}),
+		width: Flags.integer({ char: "w", description: "Render width in columns" }),
+		expanded: Flags.boolean({
+			char: "e",
+			description: "Render the expanded variant of each renderer",
+			default: false,
+		}),
+		plain: Flags.boolean({ description: "Strip ANSI styling from the output", default: false }),
+		screenshot: Flags.boolean({
+			description:
+				"Capture the rendered output as PNG screenshot(s) via VHS instead of printing ANSI (requires vhs)",
+			default: false,
+		}),
+		out: Flags.string({
+			char: "o",
+			description: "Screenshot output path (with --screenshot); suffixed per image when split across multiple",
+		}),
+		font: Flags.string({ description: "Screenshot font family (default: JetBrainsMono Nerd Font)" }),
+		"font-size": Flags.integer({ description: "Screenshot font size in points (default: 18)" }),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(Gallery);
+		await runGalleryCommand({
+			tool: flags.tool,
+			states: flags.state as GalleryState[] | undefined,
+			width: flags.width,
+			expanded: flags.expanded,
+			plain: flags.plain,
+			screenshot: flags.screenshot,
+			out: flags.out,
+			font: flags.font,
+			fontSize: flags["font-size"],
+		});
+	}
+}

package/src/commands/grep.ts

@@ -0,0 +1,48 @@
+/**
+ * Test grep tool.
+ */
+import { GrepOutputMode } from './stubs/natives/index.ts';
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { type GrepCommandArgs, runGrepCommand } from "../cli/grep-cli";
+import { initTheme } from "../modes/theme/theme";
+
+export default class Grep extends Command {
+	static description = "Test grep tool";
+
+	static args = {
+		pattern: Args.string({ description: "Regex pattern to search for", required: false }),
+		path: Args.string({ description: "Directory or file to search", required: false }),
+	};
+
+	static flags = {
+		glob: Flags.string({ char: "g", description: "Filter files by glob pattern" }),
+		limit: Flags.integer({ char: "l", description: "Max matches", default: 20 }),
+		context: Flags.integer({ char: "C", description: "Context lines", default: 2 }),
+		files: Flags.boolean({ char: "f", description: "Output file names only" }),
+		count: Flags.boolean({ char: "c", description: "Output match counts per file" }),
+		"no-gitignore": Flags.boolean({ description: "Include files excluded by .gitignore" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Grep);
+
+		const mode: GrepCommandArgs["mode"] = flags.count
+			? GrepOutputMode.Count
+			: flags.files
+				? GrepOutputMode.FilesWithMatches
+				: GrepOutputMode.Content;
+
+		const cmd: GrepCommandArgs = {
+			pattern: args.pattern ?? "",
+			path: args.path ?? ".",
+			glob: flags.glob,
+			limit: flags.limit,
+			context: flags.context,
+			mode,
+			gitignore: !flags["no-gitignore"],
+		};
+
+		await initTheme();
+		await runGrepCommand(cmd);
+	}
+}

package/src/commands/grievances.ts

@@ -0,0 +1,51 @@
+/**
+ * View, clean, and push reported tool issues from automated QA.
+ */
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { cleanGrievances, listGrievances, pushGrievances } from "../cli/grievances-cli";
+
+export default class Grievances extends Command {
+	static description = "View, clean, or push reported tool issues (auto-QA grievances)";
+
+	static args = {
+		// Positional action: "list" (default), "clean", or "push". A positional
+		// arg keeps the historical `omp grievances` invocation working unchanged
+		// while reusing the same command surface for the clean/push verbs.
+		action: Args.string({
+			description: "list (default), clean, or push",
+			required: false,
+			options: ["list", "clean", "push"],
+			default: "list",
+		}),
+	};
+
+	static flags = {
+		limit: Flags.integer({ char: "n", description: "Number of recent issues to show (list)", default: 20 }),
+		tool: Flags.string({ char: "t", description: "Filter by tool name (list, clean)" }),
+		json: Flags.boolean({ char: "j", description: "Output as JSON", default: false }),
+		id: Flags.integer({ description: "Delete a single grievance by id (clean)" }),
+		all: Flags.boolean({ description: "Delete every grievance (clean)", default: false }),
+	};
+
+	static examples = [
+		"omp grievances",
+		"omp grievances list --tool find",
+		"omp grievances clean --id 209",
+		"omp grievances clean --tool find",
+		"omp grievances clean --all",
+		"omp grievances push",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Grievances);
+		if (args.action === "clean") {
+			await cleanGrievances({ id: flags.id, tool: flags.tool, all: flags.all, json: flags.json });
+			return;
+		}
+		if (args.action === "push") {
+			await pushGrievances({ json: flags.json });
+			return;
+		}
+		await listGrievances({ limit: flags.limit, tool: flags.tool, json: flags.json });
+	}
+}

package/src/commands/install.ts

@@ -0,0 +1,107 @@
+/**
+ * `omp install <target>` — top-level convenience over `omp plugin install` /
+ * `omp plugin link`.
+ *
+ * The docs (omp.sh/docs/extension-authoring) advertise
+ *
+ *   omp install ./my-extension
+ *
+ * as a third loading mechanism that "symlinks the directory into the plugin
+ * set and watches it for changes". Before this command existed, `install` was
+ * not a registered subcommand, so the CLI runner forwarded the argv to the
+ * default `launch` command and the model received `install ./my-extension`
+ * as an initial prompt — see #1496.
+ *
+ * Local-path targets (`./foo`, `/abs/foo`, `~/foo`, or an existing directory)
+ * route to `plugin link` so they are symlinked into the plugin set, matching
+ * the documented behavior. Everything else (`pkg`, `pkg@1.2.3`,
+ * `name@marketplace`) routes to `plugin install`.
+ */
+
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { type PluginAction, type PluginCommandArgs, runPluginCommand } from "../cli/plugin-cli";
+import { initTheme } from "../modes/theme/theme";
+
+/**
+ * Heuristic used to decide whether `omp install <target>` should `link` a
+ * local directory or `install` a remote spec. Exported for tests.
+ */
+export function looksLikeLocalPath(target: string): boolean {
+	if (target.startsWith(".") || target.startsWith("/") || target.startsWith("~")) return true;
+	// Windows drive prefix (e.g. `C:\foo`).
+	if (/^[a-zA-Z]:[\\/]/.test(target)) return true;
+	// Bare names that happen to exist as a local directory.
+	try {
+		return existsSync(path.resolve(target));
+	} catch {
+		return false;
+	}
+}
+
+export default class Install extends Command {
+	static description = "Install or link an extension package (alias of `plugin install`/`plugin link`)";
+
+	static args = {
+		targets: Args.string({
+			description: "Local path, npm spec, or marketplace ref (e.g. ./my-ext, my-pkg@1.2.3, name@marketplace)",
+			required: false,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON" }),
+		force: Flags.boolean({ description: "Force install" }),
+		"dry-run": Flags.boolean({ description: "Show actions without applying changes" }),
+		scope: Flags.string({
+			description: 'Install scope: "user" (default) or "project" (marketplace installs only)',
+			options: ["user", "project"],
+		}),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Install);
+		const targets = Array.isArray(args.targets) ? args.targets : args.targets ? [args.targets] : [];
+
+		if (targets.length === 0) {
+			process.stderr.write("Usage: omp install <path | npm-spec | name@marketplace> [...]\n");
+			process.exit(1);
+		}
+
+		await initTheme();
+
+		// Split into local-paths (→ link) and remote specs (→ install). Each batch
+		// preserves user-supplied order so progress output reads naturally.
+		const localPaths: string[] = [];
+		const remoteSpecs: string[] = [];
+		for (const target of targets) {
+			if (looksLikeLocalPath(target)) localPaths.push(target);
+			else remoteSpecs.push(target);
+		}
+
+		const baseFlags: PluginCommandArgs["flags"] = {
+			json: flags.json,
+			force: flags.force,
+			dryRun: flags["dry-run"],
+			scope: flags.scope as "user" | "project" | undefined,
+		};
+
+		for (const localPath of localPaths) {
+			await runPluginCommand({
+				action: "link" satisfies PluginAction,
+				args: [localPath],
+				flags: baseFlags,
+			});
+		}
+
+		if (remoteSpecs.length > 0) {
+			await runPluginCommand({
+				action: "install" satisfies PluginAction,
+				args: remoteSpecs,
+				flags: baseFlags,
+			});
+		}
+	}
+}

package/src/commands/launch.ts

@@ -0,0 +1,169 @@
+/**
+ * Root command for the coding agent CLI.
+ */
+
+import { THINKING_EFFORTS } from "@oh-my-pi/pi-catalog/effort";
+import { APP_NAME } from "@oh-my-pi/pi-utils";
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { parseArgs } from "../cli/args";
+import { runRootCommand } from "../main";
+import { prepareAcpTerminalAuthArgs } from "../modes/acp/terminal-auth";
+
+export default class Index extends Command {
+	static description = "AI coding assistant";
+	static hidden = true;
+
+	static args = {
+		messages: Args.string({
+			description: "Messages to send (prefix files with @)",
+			required: false,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		model: Flags.string({
+			description: 'Model to use (fuzzy match: "opus", "gpt-5.2", or "openai/gpt-5.2")',
+		}),
+		smol: Flags.string({
+			description: "Smol/fast model for lightweight tasks (or PI_SMOL_MODEL env)",
+		}),
+		slow: Flags.string({
+			description: "Slow/reasoning model for thorough analysis (or PI_SLOW_MODEL env)",
+		}),
+		plan: Flags.string({
+			description: "Plan model for architectural planning (or PI_PLAN_MODEL env)",
+		}),
+		provider: Flags.string({
+			description: "Provider to use (legacy; prefer --model)",
+		}),
+		"api-key": Flags.string({
+			description: "API key (defaults to env vars)",
+		}),
+		"system-prompt": Flags.string({
+			description: "System prompt (default: coding assistant prompt)",
+		}),
+		"append-system-prompt": Flags.string({
+			description: "Append text or file contents to the system prompt",
+		}),
+		"allow-home": Flags.boolean({
+			description: "Allow starting in ~ without auto-switching to a temp dir",
+		}),
+		cwd: Flags.string({
+			description: "Directory to start in (overrides the launch cwd)",
+		}),
+		mode: Flags.string({
+			description: "Output mode: text (default), json, rpc, or rpc-ui",
+			options: ["text", "json", "rpc", "acp", "rpc-ui"],
+		}),
+		config: Flags.string({
+			description: "Load an extra config.yml-style overlay for this run (repeatable)",
+			multiple: true,
+		}),
+		print: Flags.boolean({
+			char: "p",
+			description: "Non-interactive mode: process prompt and exit",
+		}),
+		continue: Flags.boolean({
+			char: "c",
+			description: "Continue previous session",
+		}),
+		resume: Flags.string({
+			char: "r",
+			description: "Resume a session (by ID prefix, path, or picker if omitted)",
+		}),
+		"session-dir": Flags.string({
+			description: "Directory for session storage and lookup",
+		}),
+		"no-session": Flags.boolean({
+			description: "Don't save session (ephemeral)",
+		}),
+		models: Flags.string({
+			description: "Comma-separated model patterns for Ctrl+P cycling",
+		}),
+		"no-tools": Flags.boolean({
+			description: "Disable all built-in tools",
+		}),
+		"no-lsp": Flags.boolean({
+			description: "Disable LSP tools, formatting, and diagnostics",
+		}),
+		"no-pty": Flags.boolean({
+			description: "Disable PTY-based interactive bash execution",
+		}),
+		tools: Flags.string({
+			description: "Comma-separated list of tools to enable (default: all)",
+		}),
+		thinking: Flags.string({
+			description: `Set thinking level: ${THINKING_EFFORTS.join(", ")}`,
+			options: [...THINKING_EFFORTS],
+		}),
+		"hide-thinking": Flags.boolean({
+			description: "Hide thinking blocks in TUI output (display only, does not disable model thinking)",
+		}),
+		hook: Flags.string({
+			description: "Load a hook/extension file (can be used multiple times)",
+			multiple: true,
+		}),
+		extension: Flags.string({
+			char: "e",
+			description: "Load an extension file (can be used multiple times)",
+			multiple: true,
+		}),
+		"no-extensions": Flags.boolean({
+			description: "Disable extension discovery (explicit -e paths still work)",
+		}),
+		"no-skills": Flags.boolean({
+			description: "Disable skills discovery and loading",
+		}),
+		skills: Flags.string({
+			description: "Comma-separated glob patterns to filter skills (e.g., git-*,docker)",
+		}),
+		"no-rules": Flags.boolean({
+			description: "Disable rules discovery and loading",
+		}),
+		export: Flags.string({
+			description: "Export session file to HTML and exit",
+		}),
+		"list-models": Flags.string({
+			description: "List available models (with optional fuzzy search)",
+		}),
+		"no-title": Flags.boolean({
+			description: "Disable title auto-generation",
+		}),
+		// `--auto-approve` / `--yolo`: declared here so oclif's auto-generated `--help` lists it.
+		// Runtime parsing happens in `cli/args.ts parseArgs` (line 176 in that file) — `runRootCommand`
+		// consumes the manual-parser output, not these oclif flag values. If you rename or remove
+		// either form, update both call sites in lockstep.
+		"auto-approve": Flags.boolean({
+			aliases: ["yolo"],
+			description: "Auto-approve all tool calls (skip approval prompts)",
+		}),
+		// `--approval-mode`: declared here so oclif's auto-generated `--help` lists it; runtime parsing
+		// happens in `cli/args.ts parseArgs`. The value is applied via `Settings.override("tools.approvalMode", …)`
+		// in `main.ts` after the `Settings` instance is constructed, so every `settings.get("tools.approvalMode")`
+		// site (wrapper, `/settings` UI) observes the same value.
+		"approval-mode": Flags.string({
+			options: ["always-ask", "write", "yolo"],
+			description: "Override tools.approvalMode for this session (always-ask|write|yolo)",
+		}),
+	};
+
+	static examples = [
+		`# Interactive mode\n  ${APP_NAME}`,
+		`# Interactive mode with initial prompt\n  ${APP_NAME} "List all .ts files in src/"`,
+		`# Include files in initial message\n  ${APP_NAME} @prompt.md @image.png "What color is the sky?"`,
+		`# Non-interactive mode (process and exit)\n  ${APP_NAME} -p "List all .ts files in src/"`,
+		`# Continue previous session\n  ${APP_NAME} --continue "What did we discuss?"`,
+		`# Use different model (fuzzy matching)\n  ${APP_NAME} --model opus "Help me refactor this code"`,
+		`# Limit model cycling to specific models\n  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o`,
+		`# Export a session file to HTML\n  ${APP_NAME} --export ~/.omp/agent/sessions/--path--/session.jsonl`,
+	];
+
+	static strict = false;
+
+	async run(): Promise<void> {
+		const { args } = prepareAcpTerminalAuthArgs(this.argv);
+		const parsed = parseArgs(args);
+		await runRootCommand(parsed, args);
+	}
+}

package/src/commands/plugin.ts

@@ -0,0 +1,78 @@
+/**
+ * Manage plugins (install, uninstall, list, etc.).
+ */
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { type PluginAction, type PluginCommandArgs, runPluginCommand } from "../cli/plugin-cli";
+import { initTheme } from "../modes/theme/theme";
+
+const ACTIONS: PluginAction[] = [
+	"install",
+	"uninstall",
+	"list",
+	"link",
+	"doctor",
+	"features",
+	"config",
+	"enable",
+	"disable",
+	"marketplace",
+	"discover",
+	"upgrade",
+];
+
+export default class Plugin extends Command {
+	static description = "Manage plugins (install, uninstall, list, etc.)";
+
+	static args = {
+		action: Args.string({
+			description: "Plugin action",
+			required: false,
+			options: ACTIONS,
+		}),
+		targets: Args.string({
+			description: "Packages, paths, or plugin names",
+			required: false,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON" }),
+		fix: Flags.boolean({ description: "Attempt to fix issues (doctor)" }),
+		force: Flags.boolean({ description: "Force install" }),
+		"dry-run": Flags.boolean({ description: "Show actions without applying changes" }),
+		local: Flags.boolean({ char: "l", description: "Operate on local plugin directory" }),
+		enable: Flags.string({ description: "Enable a feature" }),
+		disable: Flags.string({ description: "Disable a feature" }),
+		set: Flags.string({ description: "Set plugin config (key=value)" }),
+		scope: Flags.string({
+			description: 'Install scope: "user" (default) or "project"',
+			options: ["user", "project"],
+		}),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Plugin);
+		const action = (args.action ?? "list") as PluginAction;
+
+		const targets = Array.isArray(args.targets) ? args.targets : args.targets ? [args.targets] : [];
+		const cmd: PluginCommandArgs = {
+			action,
+			args: targets,
+			flags: {
+				json: flags.json,
+				fix: flags.fix,
+				force: flags.force,
+				dryRun: flags["dry-run"],
+				local: flags.local,
+				enable: flags.enable,
+				disable: flags.disable,
+				set: flags.set,
+				scope: flags.scope as "user" | "project" | undefined,
+			},
+		};
+
+		await initTheme();
+		await runPluginCommand(cmd);
+	}
+}

package/src/commands/read.ts

@@ -0,0 +1,38 @@
+/**
+ * Show what the read tool will return for a path, URL, or internal URI.
+ */
+import { Args, Command } from "@oh-my-pi/pi-utils/cli";
+import { type ReadCommandArgs, runReadCommand } from "../cli/read-cli";
+import { initTheme } from "../modes/theme/theme";
+
+export default class Read extends Command {
+	static description = "Show what the read tool will return for a path, URL, or internal URI";
+
+	static args = {
+		path: Args.string({
+			description:
+				"Path, URL, or internal URI to read (append :sel for line ranges or raw mode, e.g. src/foo.ts:50-100)",
+			required: true,
+		}),
+	};
+
+	static examples = [
+		"omp read src/foo.ts",
+		"omp read src/foo.ts:50-100",
+		"omp read src/foo.ts:raw",
+		"omp read https://example.com",
+		"omp read omp://",
+		"omp read issue://123",
+		"omp read path/to/archive.zip:dir/file.ts",
+		"omp read path/to/db.sqlite:users:42",
+	];
+
+	async run(): Promise<void> {
+		const { args } = await this.parse(Read);
+		const cmd: ReadCommandArgs = {
+			path: args.path ?? "",
+		};
+		await initTheme();
+		await runReadCommand(cmd);
+	}
+}

package/src/commands/setup.ts

@@ -0,0 +1,67 @@
+/**
+ * Run onboarding setup or install dependencies for optional features.
+ */
+import { Args, Command, Flags, renderCommandHelp } from "@oh-my-pi/pi-utils/cli";
+import { parseArgs } from "../cli/args";
+import { runSetupCommand, type SetupCommandArgs, type SetupComponent } from "../cli/setup-cli";
+import { runRootCommand } from "../main";
+import { initTheme } from "../modes/theme/theme";
+
+const COMPONENTS: SetupComponent[] = ["python", "stt"];
+
+export interface OnboardingSetupDependencies {
+	runRoot?: typeof runRootCommand;
+	stdinIsTTY?: boolean;
+	stdoutIsTTY?: boolean;
+	writeStderr?: (text: string) => void;
+	exit?: (code: number) => never;
+}
+
+export async function runOnboardingSetup(deps: OnboardingSetupDependencies = {}): Promise<void> {
+	const stdinIsTTY = deps.stdinIsTTY ?? process.stdin.isTTY;
+	const stdoutIsTTY = deps.stdoutIsTTY ?? process.stdout.isTTY;
+	if (!stdinIsTTY || !stdoutIsTTY) {
+		(deps.writeStderr ?? (text => process.stderr.write(text)))("omp setup requires an interactive TTY.\n");
+		(deps.exit ?? process.exit)(1);
+		return;
+	}
+	await (deps.runRoot ?? runRootCommand)(parseArgs([]), [], { forceSetupWizard: true });
+}
+
+export default class Setup extends Command {
+	static description = "Run onboarding setup or install dependencies for optional features";
+
+	static args = {
+		component: Args.string({
+			description: "Optional component to install",
+			required: false,
+			options: COMPONENTS,
+		}),
+	};
+
+	static flags = {
+		check: Flags.boolean({ char: "c", description: "Check if dependencies are installed" }),
+		json: Flags.boolean({ description: "Output status as JSON" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Setup);
+		if (!args.component) {
+			if (flags.check || flags.json) {
+				renderCommandHelp("omp", "setup", Setup);
+				return;
+			}
+			await runOnboardingSetup();
+			return;
+		}
+		const cmd: SetupCommandArgs = {
+			component: args.component as SetupComponent,
+			flags: {
+				json: flags.json,
+				check: flags.check,
+			},
+		};
+		await initTheme();
+		await runSetupCommand(cmd);
+	}
+}

package/src/commands/shell.ts

@@ -0,0 +1,29 @@
+/**
+ * Interactive shell console.
+ */
+import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { runShellCommand, type ShellCommandArgs } from "../cli/shell-cli";
+import { initTheme } from "../modes/theme/theme";
+
+export default class Shell extends Command {
+	static description = "Interactive shell console";
+
+	static flags = {
+		cwd: Flags.string({ char: "C", description: "Set working directory for commands" }),
+		timeout: Flags.integer({ char: "t", description: "Timeout per command in milliseconds" }),
+		"no-snapshot": Flags.boolean({ description: "Skip sourcing snapshot from user shell" }),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(Shell);
+
+		const cmd: ShellCommandArgs = {
+			cwd: flags.cwd,
+			timeoutMs: flags.timeout,
+			noSnapshot: flags["no-snapshot"],
+		};
+
+		await initTheme();
+		await runShellCommand(cmd);
+	}
+}