Introduction

In our previous article, Wheels CLI: Modern Commands for Faster, Smarter Wheels 3.0 Development, we introduced the new generation of CLI capabilities coming to Wheels 3.x.

That article focused on the big picture — how the CLI is evolving beyond scaffolding into a complete development companion.

Now it’s time to zoom in.

This article explores three powerful inspection commands that help you understand your application’s current state instantly:

• wheels about
• wheels get environment
• wheels get settings These commands are not about generating code. They’re about visibility, awareness, and confidence. When debugging, deploying, or supporting an application, knowing your environment and configuration matters just as much as writing good code.

Why App Inspection Commands Matter

Modern development environments are rarely simple. You may have:

• Multiple environments (development, staging, production)
• Different configuration overrides
• Environment-specific settings
• Multiple framework versions across projects
• Team members working on different machines Without proper visibility, confusion happens quickly.

Questions like:

• “Which environment am I in?”
• “Is caching enabled here?”
• “Why is this behaving differently in staging?”
• “What version of Wheels is this app using?”

The new CLI inspection commands answer these instantly.

• No digging through files.
• No guessing.
• No assumptions. Just clarity.

wheels about

Your Application’s Full Snapshot The about command provides a complete overview of your Wheels application. wheels about

It displays:

• Wheels framework version
• CFML engine information
• Application name
• Current environment
• Configuration status
• Key runtime details
• Application statistics Think of it as your application’s diagnostic summary.

When to Use about Debugging Issues: If something behaves unexpectedly, start with: wheels about

You’ll quickly see:

• Whether you’re in the correct environment
• Which framework version is running
• Whether configuration values are being picked up properly

Support & Collaboration: When helping a teammate, the first question often is: “What version are you running?” Instead of manually checking files, they can simply run: wheels about

It standardizes the way teams share environment information.

Deployment Validation: After deploying to staging or production, you can verify:

• Correct environment detection
• Correct configuration loading
• Framework version consistency It’s a fast sanity check before declaring deployment success.

Why about Is Powerful:

• Reduces troubleshooting time
• Prevents environment confusion
• Makes support conversations easier
• Encourages environmental awareness

It’s your first command when something feels “off.”

wheels get environment

Know Exactly Where You Are Modern apps typically run in multiple environments:

• development
• testing
• staging
• production
• maintenance The get environment command tells you exactly which one your app is currently using. wheels get environment

What It Shows

• Active environment name
• How it was detected
• Where the configuration is coming from This eliminates guesswork. No more manually inspecting configuration files.

Why This Is Important Environment mismatches are one of the most common causes of bugs. For example:

• Caching enabled in staging but not locally
• Different database connections
• Different mail server settings
• Debug mode accidentally enabled in production

Instead of wondering, just run: wheels get environment

Instant clarity.

Real-World Scenario Imagine deploying to staging and noticing unexpected behavior. You assume it’s running in staging. But what if the environment variable wasn’t set correctly? Running: wheels get environment

Immediately confirms whether your assumption is correct. This command alone can save hours of debugging.

wheels get settings

Inspect Your Active Configuration The get settings command shows the current Wheels application settings for your active environment. wheels get settings

It displays:

• All active configuration values
• Default settings
• Custom overrides
• Environment-specific configurations You can also filter for specific settings if needed.

Why This Command Is Critical Configuration issues are subtle. Sometimes:

• A setting exists in one environment but not another
• A default value is overriding a custom one
• A configuration file isn’t being loaded as expected Instead of manually opening multiple config files, this command aggregates everything into one clear output.

Practical Use Cases Troubleshooting: If something related to caching, sessions, or routing behaves differently: wheels get settings

You’ll immediately see:

• What’s enabled
• What’s disabled
• What values are active

Configuration Validation: Before going live:

• Confirm debugging is disabled
• Confirm production caching is enabled
• Confirm mail settings are correct
• Confirm custom overrides are loaded This command provides verification without manual inspection.

The Bigger Picture: These commands represent an important shift in the CLI philosophy. Older CLI commands focused on generating files. These new commands focus on observability and awareness.

They help you:

• Understand your app
• Validate your configuration
• Debug faster
• Avoid environment confusion
• Collaborate more efficiently In modern development, visibility is productivity.

How These Commands Work Together

Here’s a practical workflow:

Step 1 – Confirm Environment wheels get environment

Make sure you’re in the expected environment.

Step 2 – Inspect Configuration wheels get settings

Verify important configuration values.

Step 3 – Full Diagnostic Overview wheels about

Review the full application snapshot. Together, they provide a complete picture of your application’s runtime state.

What This Means for Wheels Developers

With these inspection tools, Wheels CLI is evolving into more than just a scaffolding tool. It’s becoming:

• A diagnostic assistant
• A configuration validator
• An environment inspector
• A debugging companion

And this is just the beginning.

In upcoming articles, we’ll continue exploring:

• Environment management tools
• Database utilities
• Testing automation commands
• Asset workflows
• Documentation generation
• Advanced plugin tooling

Each module builds toward one goal:

• More control.
• More clarity.
• More confidence.

Conclusion

The new inspection commands in Wheels CLI 3.x are small in size — but huge in impact.

• wheels about gives you a full application snapshot
• wheels get environment removes environment guesswork.
• wheels get settings exposes active configuration instantly.

If earlier CLI commands helped you build faster… These help you debug smarter.

And in modern development, smart debugging is just as important as fast coding.

Stay tuned — the next deep dive is coming.

Learn more here: https://www.youtube.com/watch?v=NHx3-wncyFw