If you’ve ever typed php artisan and scrolled through a wall of commands trying to remember the exact name of that one migration command, you already understand the problem this tool solves.

Why Artisan’s Default Interface Falls Short

Laravel’s Artisan CLI is genuinely powerful. With dozens of built-in commands and however many your project adds through packages or custom code, it’s the control center of every Laravel application. But the default discovery experience is, charitably, primitive.

You run php artisan list, get a wall of text, and squint to find what you need. If you’re jumping between multiple projects with different packages installed, remembering which commands exist where becomes real cognitive overhead. There’s no filtering, no argument preview, no way to run a command without leaving to type it out manually.

This is exactly the gap that Laravel Artisan TUI fills — and if you haven’t tried it yet, it earns a permanent spot in your workflow within about ten minutes.

Browse and Execute Artisan Commands from an Interactive TUI: What It Actually Is

The package we’re talking about is \artisan-tui“ (also surfaced via Laravel News), a terminal user interface that wraps Artisan’s command system in a navigable, filterable, keyboard-driven interface.

Instead of typing php artisan list and scanning output, you get a full-screen TUI built on top of Laravel Prompts and the underlying terminal rendering capabilities it exposes. The interface lets you:

• Browse every registered Artisan command in a scrollable list
• Filter commands by typing a search string in real time
• Preview command signatures, arguments, and options inline
• Execute commands directly — with argument prompts — without leaving the interface

This is the kind of tool that seems like a luxury until you use it and then can’t imagine going back.

Installation

Getting it running takes about thirty seconds:

composer require --dev liamtseva/artisan-tui

Once installed, launch it with:

php artisan tui

That’s it. No config file, no service provider registration in newer Laravel versions — the package auto-discovers via Package Auto-Discovery.

What the Interface Looks Like

When you launch php artisan tui, you land in a full-screen terminal view. The left panel shows a filterable list of all registered commands grouped by namespace (e.g., make:, migrate:, cache:). The right panel renders the command’s description, signature, arguments, and options dynamically as you move the cursor.

Navigation is exactly what you’d expect from a well-built TUI:

• Arrow keys or j/k to move through the list
• Type to filter — the list narrows in real time
• Enter to select and execute a command
• q or Escape to exit

When you execute a command that requires arguments, you’re prompted interactively before the command runs — so you don’t have to remember the argument order.

How to Browse and Execute Artisan Commands from an Interactive TUI in Practice

Let me walk through a real workflow to show why this matters beyond the demo.

Running Migrations Interactively

Say you’re debugging a staging environment issue and you need to check which migrations have run, roll back a specific batch, then re-run. Normally this is three separate terminal commands with flags you half-remember.

In the TUI, you type migr and the list immediately narrows to:

migrate
migrate:fresh
migrate:install
migrate:refresh
migrate:reset
migrate:rollback
migrate:status

You select migrate:status first — no arguments needed, it runs immediately and outputs to the same terminal. Then you select migrate:rollback, and you’re prompted for --step inline before it executes.

The feedback loop is dramatically tighter. You’re not context-switching between a documentation tab, your terminal history, and the command itself.

Exploring an Unfamiliar Project

This is where the TUI genuinely shines for developers working with AI-generated codebases or inherited projects. When you take over a Laravel project — or spin up a codebase that a tool like Laravel Shift or an AI assistant scaffolded — you often don’t know what custom commands exist.

With php artisan list, you get everything dumped at once. With the TUI, you can scroll through the app: namespace and read each command’s description while navigating. It’s closer to browsing an API reference than reading raw CLI output. That’s not a small difference.

This matters especially when you’re working AI-assisted. You can use a tool like GitHub Copilot or Cursor to generate a command, then jump into the TUI to verify it registered correctly and execute it with the right arguments — all without leaving the terminal context.

Custom Commands and Argument Prompting

If you’ve written a custom Artisan command with required arguments:

protected $signature = 'import:products {source : The CSV file path} {--dry-run : Preview without importing}';

The TUI will show this signature in the preview panel and prompt you for source when you execute it, with the description text visible. Compare this to the normal experience where you’d run php artisan import:products, get an error about a missing argument, then go check the signature. I’ve done that embarrassing dance more times than I’d like to admit.

Under the Hood: How the TUI Is Built

Understanding the internals helps you extend it and reason about edge cases.

Laravel Artisan TUI uses Laravel Prompts for its interactive input handling. Laravel Prompts, introduced in Laravel 10, provides a clean abstraction over termwind and lower-level terminal control sequences — which is why it renders cleanly across macOS, Linux, and modern Windows terminals running WSL.

The command list is pulled directly from the Application’s registered commands via $this->getApplication()->all() — the same source that php artisan list uses. This means:

• Custom commands you register via service providers appear automatically
• Commands registered by third-party packages appear automatically
• The list is always accurate for the current environment

There’s no caching layer, so it’s always reflecting the real state of the application. The slight startup overhead is worth that accuracy guarantee. Don’t mess with caching here — stale command lists are worse than slow ones.

What It Does Not Do (Yet)

Being direct about limitations matters:

• No command history — there’s no log of previously executed commands within the TUI
• No output capture — command output streams directly to the terminal rather than being captured and displayed in a dedicated panel
• No multi-step workflows — you run one command and return to the list; you can’t chain them

These are reasonable constraints for a tool at this stage. The output behavior in particular is a deliberate design choice — capturing stdout from arbitrary Artisan commands and re-rendering it introduces significant complexity and edge cases. Anyone who’s tried to build that knows why they skipped it.

Integrating This Into a Dev Workflow With AI Tooling

If you’re building Laravel applications with AI assistance, the TUI fits naturally into a specific moment in the workflow: validation after generation.

The pattern looks like this:

1. Use an AI assistant to scaffold a feature — controllers, models, migrations, custom commands
2. Open the TUI to verify all generated commands registered correctly
3. Execute make: commands if needed to fill gaps
4. Run migrations and seeders interactively

This is more efficient than typing each command from memory or hunting through AI-generated documentation about what was just scaffolded. The TUI gives you a live, accurate inventory of what the application can do right now. Why would you want anything less than that?

You can also pair it with Laravel Telescope — run commands through the TUI in a local environment and watch Telescope capture the queries, jobs, and events triggered, giving you a full trace of what each command actually does.

Conclusion

The ability to browse and execute Artisan commands from an interactive TUI sounds like a quality-of-life improvement, and it is — but it’s also a fundamentally better mental model for working with Artisan. Discovery, preview, and execution in a single interface cuts the friction that makes developers avoid CLI tools they should be using regularly.

If your workflow involves any combination of unfamiliar codebases, AI-assisted development, or frequent Artisan usage, install this package today. The thirty-second setup cost pays for itself the first time you need to find a command you half-remember.

The fact that it builds on Laravel Prompts also means it’s aligned with where Laravel’s first-party tooling is heading — so betting on this approach is a reasonable long-term call, not just a neat trick.

composer require --dev liamtseva/artisan-tui && php artisan tui

Browse and execute Artisan commands from an interactive TUI. That’s the whole pitch. It’s enough.