DEV Community: David Minaya

How to Use AI in the Terminal: A Simpler, Safer Approach

David Minaya — Mon, 02 Feb 2026 13:50:32 +0000

AI is omnipresent nowadays. We find it everywhere: on the web, in desktop applications, on our phones, and naturally, in our terminals (command-line interfaces).

But what is the best way to run AI from the terminal?

Sure, we have several powerful options like Claude, Gemini, Windsurf, or OpenCode. We can even run AI locally using tools like llama.cpp, Ollama, or LMStudio.

These are incredibly powerful tools, excellent for complex tasks, but they can be overkill for simple day-to-day needs. They often come with complex configurations, dozens of options, and can sometimes take over a minute to respond. Furthermore, if you don't use them carefully, they can execute harmful actions on your computer without your knowledge - such as running risky commands, deleting files, or exposing your system to security vulnerabilities like prompt injection.

Is there a better way?

The answer is yes.

Today, I want to introduce you to Ask CLI, an open-source, fast, and secure AI tool. You can use it directly in your terminal like a normal command to do different things: remember how to use commands, ask questions about your system or learn how to use Linux.

Ask CLI is designed to help you find the information you need without leaving the terminal or losing your focus.

Why use Ask CLI instead of the alternatives?

Ask CLI offers several advantages over other alternatives:

It is easy to use: You don't have dozens of options to manage. Forget about complex settings, configuration files, or memorizing a lot of different flags.
It runs on any terminal: It works seamlessly in Bash, PowerShell, CMD, inside Docker containers, and more.
It fits your workflow: It runs like a standard command. Many alternatives are designed to run in an interactive mode with a TUI (Text User Interface). While cool, TUIs force you to stop interacting with your terminal and start interacting with the tool, which can break your focus.
It is fast and lightweight: While other tools can take over a minute and generate long responses, Ask CLI is optimized to generate short, precise and fast answers. It gives you just the info you need to continue working.
It is inherently secure: It cannot run commands on your computer or access your files by itself. This completely eliminates the risk of prompt injection, running dangerous commands, or deleting important data.
It is cheaper: While other alternatives burn thousands of tokens to generate a response, Ask CLI generates short answers using fewer tokens.

Who is Ask CLI for?

This app is useful for anyone who spends time in a terminal: developers, DevOps engineers, system administrators, or anyone learning Linux.

Ask CLI is particularly valuable in environments where security is paramount, such as production servers, master nodes, or personal computers containing sensitive data.

Running a full AI Agent on a server with critical infrastructure isn't a good idea; you are opening the door to new types of attack vectors. A bad actor could potentially use prompt injection to trick an agent into sending your information to a remote server or executing malicious code.

With Ask CLI, you don't have these problems. Because it cannot execute commands or read files on its own, a prompt injection attack is rendered useless. You are always the one hitting Enter.

Note: You can even connect Ask CLI to a local model (via Ollama, etc.) for maximum privacy and security.

How to start using Ask CLI

It is very simple. Ask CLI runs on Node.js, so if you have Node installed, you can install it easily using NPM.

If you don't have Node installed, you can get it from the official website.

Once Node is ready, run this command to install Ask CLI:

npm install -g ask-cli-ai

How to use it

Using Ask CLI is intuitive. Just run the command ask followed by whatever you want to know.

ask how to copy a file

The first time you use it, it will ask you to select the model you want to use and input your API key. After that, you are good to go!

You can learn more about Ask CLI and its documentation here:
https://github.com/david-minaya/ask

If you have any questions about how to use Ask CLI, please leave me a comment!

Stop Googling Commands: Meet Your New AI Terminal Assistant 🚀

David Minaya — Thu, 29 Jan 2026 22:35:49 +0000

We’ve all been there. You’re in the flow, coding away, and suddenly you hit a wall. You need to untar a file, but you forgot the flags. Or maybe you want to know the difference between git merge and rebase without reading a 10-minute article.

You Alt+Tab away from your terminal, open a browser, Google it, scroll past the ads, find the Stack Overflow answer, copy the command, switch back to the terminal, and paste it.

Flow = Broken. 🛑

I wanted a way to get answers inside the terminal without the fluff. I wanted something fast, lightweight, and safe.

Meet Ask CLI.

What is Ask CLI? 🤖

ask-cli-ai is a lightweight Node.js tool that connects your terminal to top-tier AI models (Gemini, OpenAI, Anthropic, or even local models).

It is designed to do one thing and do it well: Get you the info you need and get out of your way.

Why another AI tool?

There are plenty of AI "agents" out there, but many of them try to do too much. They want to write your whole codebase, or worse, they try to execute dangerous commands on your behalf without you knowing.

Ask CLI is different:

It's Safe: It cannot run commands or access files without your explicit authorization.
It's Fast: Optimized for blazing-fast, short, and precise answers.
It's Flexible: Use Gemini, GPT, Claude, or connect to your local Llama instance.

Installation ⚡

Installation is a breeze via npm:

npm install -g ask-cli-ai

Once installed, you can configure your preferred model (supports Gemini, OpenAI, Anthropic, etc.) with ask /models.

How to use it

The goal is to be conversational. You can use ask, or the aliases how and what.

1. The "I forgot the syntax" moment
Instead of Googling, just ask:

ask how to create a zip file with password
# or
how to revert the last git commit

2. Understanding concepts
Quickly get definitions without context switching:

what is the difference between git merge and rebase

3. Analyzing specific outputs
By default, Ask CLI doesn't see your terminal screen or run commands. However, if you specifically want it to analyze an error or a log, you can use the -c (command) flag. This runs the command you provide and sends the output to the AI for explanation.

# Debug a build error
ask why is this failing -c "npm run build"

# Explain a command's output
ask explain this output -c "docker ps -a"

Bring Your Own Model 🧠

One size doesn't fit all. Ask CLI supports a massive range of models, including the latest previews from Google (Gemini 3 Flash/Pro), OpenAI (GPT-5, GPT-4.1), and Anthropic (Claude 4.5).

Privacy focused?
You can even connect it to local providers (like Ollama or llama.cpp) using the OpenAI-compatible API connector.

ask /connect

Give it a try

If you want to stay in the terminal and keep your flow state intact, give it a shot. It’s open source and available on NPM.

📦 NPM: npmjs.com/package/ask-cli-ai
💻 GitHub: David-Minaya/ask

Let me know what you think in the comments! Happy coding. 🚀

Validating Environment Variables in Node

David Minaya — Tue, 10 Jun 2025 00:39:15 +0000

Environment variables are a cornerstone of modern application development, allowing us to configure behavior across different environments (development, staging, production) without changing code. From database credentials to API keys and feature flags, they are the glue that makes our applications portable and scalable. However, relying on them without proper validation is a recipe for disaster.

An application might crash on startup, behave erratically, or even expose security vulnerabilities simply because an environment variable was missing, misspelled, or in the wrong format. In this guide, we'll explore the critical importance of validating environment variables in Node.js. We'll start by looking at a manual approach and then dive into a powerful, modern library, env-type-validator, that makes the process seamless, type-safe, and robust.

The Importance of Validating Environment Variables

Validating environment variables at application startup is a critical practice that enforces a contract between your code and its environment. It's about failing fast and explicitly. Instead of letting your application run in an invalid state that could lead to cryptic runtime errors, you ensure all required configurations are present and correct from the very beginning.

This upfront check provides several key benefits:

Increased Reliability: Prevents the application from starting in a broken state.
Enhanced Security: Ensures that sensitive or critical variables, like NODE_ENV or API_SECRET, are correctly set.
Improved Developer Experience: Catches configuration errors immediately, providing clear feedback about what's wrong. This avoids the dreaded "it works on my machine" problem.
Predictable Behavior: Guarantees that variables are of the correct type (e.g., a port is a number, not a string).

What Problems Can Be Avoided?

By implementing a robust validation strategy, you can sidestep a host of common and frustrating issues:

Unexpected Crashes: If your application expects a PORT to be a number but it's undefined, a call to server.listen(process.env.PORT) could fail silently or crash the process.
Silent Failures & Logical Errors: Imagine a boolean feature flag ENABLE_LOGS. In Node.js, all environment variables are strings. If you check if (process.env.ENABLE_LOGS), the string "false" is truthy, meaning the condition will pass when you intended it to fail. The feature will run when it shouldn't, potentially causing incorrect behavior that is difficult to trace.
Security Vulnerabilities: If NODE_ENV is not explicitly set to "production", frameworks like Express might default to a development mode, which can leak stack traces and other sensitive information in response to errors.
Difficult Debugging: An invalid database URL could lead to a cryptic connection timeout error deep within a database driver, sending you on a wild goose chase. Validating the URL format at startup would have pointed to the exact problem immediately.

How to Validate Environment Variables Manually

Before reaching for a library, it's useful to understand how to perform validation manually. This approach works for small projects but quickly becomes cumbersome and error-prone as your application grows.

Let's say we have the following requirements for our .env file:

DB_HOST: Required, must be a string.
DB_PORT: Required, must be a valid port number.
NODE_ENV: Optional, defaults to "development".

Here’s how you might write a manual validation script:

// config.ts

// Load environment variables (e.g., using dotenv)
import 'dotenv/config';

const config = {
  dbHost: process.env.DB_HOST,
  dbPort: process.env.DB_PORT,
  nodeEnv: process.env.NODE_ENV || 'development',
};

// 1. Validate DB_HOST
if (!config.dbHost) {
  throw new Error('Missing required environment variable: DB_HOST');
}

// 2. Validate DB_PORT
const port = parseInt(config.dbPort, 10);

if (isNaN(port) || port <= 0 || port > 65535) {
  throw new Error('Invalid environment variable: DB_PORT must be a valid port number.');
}

config.dbPort = port; // Overwrite with the parsed number

// Export a frozen object to prevent modification
export default Object.freeze(config);

While this works, you can see the boilerplate. For every new variable, you need more if statements, parsing logic, and custom error messages. This process is repetitive and not easily scalable.

A Better Way: Using `env-type-validator`

This is where specialized libraries come in. env-type-validator is a package designed to validate, parse, and type your environment variables declaratively. It uses a clear and concise syntax to define your configuration schema, and it fails fast with descriptive errors if the validation doesn't pass.

Key Features

Let's explore the features that make this package a superior choice for any Node.js project.

1. Declarative Validation and Parsing

Instead of writing imperative checks, you declare what your environment variables should look like. The library handles the rest. If validation succeeds, it returns a parsed and typed object. If not, it throws a helpful error.

Consider this .env file:

# .env
DB_NAME=production_db
HOST=localhost
PORT=8080
ENABLE_LOGS=yes

You can validate it with the following code:

// env.ts
import validate, { string, number, boolean } from 'env-type-validator';

const env = validate({
  DB_NAME: string(),
  HOST: string(),
  PORT: number(),
  ENABLE_LOGS: boolean({ trueValue: 'yes' })
});

export default env;

This approach is cleaner, more readable, and less prone to manual errors.

2. Automatic Type Inference

For TypeScript users, env-type-validator provides a massive advantage: type inference. The returned object is fully typed based on the validators you use.

string() returns a string.
number() returns a number.
boolean() returns a boolean.
number({ optional: true }) returns a number | undefined.
number({ optional: true, defaultValue: 3000 }) returns a number.

This means you get full autocompletion and compile-time safety across your application, eliminating a whole class of bugs.

3. A Rich Set of Built-in Validators

The library comes with a comprehensive set of over 25 built-in validators, covering everything from simple primitives to complex formats. It leverages the battle-tested validator.js library for many of these checks.

Some of the most useful validators include:

Primitives: string(), number(), float(), boolean().
Network: url(), ip(), port(), mac().
Formats: email(), uuid(), jwt(), json(), base64(), hex().
Constraints: enumm({ enum: [...] }), regex({ regex: /.../ }).

Each validator comes with its own set of options, such as min/max for numbers, length for strings, and optional or defaultValue for any variable.

4. Custom Validators

What if you have a unique validation requirement not covered by the built-in functions? env-type-validator offers an elegant solution with custom validators.

You can define a validator object with a validate function and an optional parse function.

validate: Returns { isValid: true } or { isValid: false, error: '...' }.
parse: Transforms the input string into the desired output type.

For example, let's validate a comma-separated list of strings, like ALLOWED_ORIGINS=http://localhost:3000,https://example.com.

import validate from 'env-type-validator';

const env = validate({
  ALLOWED_ORIGINS: {
    validate: (key, value) => {
      return { 
        isValid: value !== undefined && /^(\w+,)+\w+$/.test(value)
      }
    },
    parse: (value) => {
      // The return type of parse determines the inferred type.
      // Here, it will be string[].
      return value.split(',');
    },
  },
});

// env.ALLOWED_ORIGINS is now correctly typed as string[]
// Example: ['http://localhost:3000', 'https://example.com']

This extensibility ensures that no matter how complex your configuration needs are, you can handle them within the same consistent and declarative framework.

Conclusion

Configuration is the foundation of any application. By validating your environment variables, you fortify that foundation against instability, insecurity, and unpredictable behavior. While manual validation is possible, it introduces boilerplate and risk.

Tools like env-type-validator transform this crucial task from a tedious chore into a simple, declarative process. By integrating it into your Node.js projects, you not only catch errors early but also improve code clarity and gain the immense benefits of type safety. Make environment variable validation a non-negotiable step in your development workflow—your future self will thank you.

DEV Community: David Minaya

How to Use AI in the Terminal: A Simpler, Safer Approach

Is there a better way?

Why use Ask CLI instead of the alternatives?

Who is Ask CLI for?

How to start using Ask CLI

How to use it

Stop Googling Commands: Meet Your New AI Terminal Assistant 🚀

What is Ask CLI? 🤖

Why another AI tool?

Installation ⚡

How to use it

Bring Your Own Model 🧠

Give it a try

Validating Environment Variables in Node

The Importance of Validating Environment Variables

What Problems Can Be Avoided?

How to Validate Environment Variables Manually

A Better Way: Using env-type-validator

Key Features

1. Declarative Validation and Parsing

2. Automatic Type Inference

3. A Rich Set of Built-in Validators

4. Custom Validators

Conclusion

A Better Way: Using `env-type-validator`