Posted on
• Artificial Intelligence

Artificial Intelligence Linux Command-Line Tips

Author
  • User
    linuxbash
    Posts by this author
    Posts by this author

Artificial Intelligence Linux Command‑Line Tips: Supercharge Bash Without Leaving Your Terminal

Ever Alt‑Tabbed to a browser just to ask AI for a quick command, regex, or log summary—then lost flow? Bringing AI directly into your terminal keeps you focused, faster, and reproducible. In this guide, you’ll wire up both cloud and local AI (privacy‑friendly) to your shell, then use small Bash helpers to generate commands safely, explain pipelines, and summarize logs on the fly.

What you’ll get:

  • Practical, drop‑in Bash functions you can paste into your shell

  • Cloud and offline (local) AI options

  • Actionable examples for real admin/dev workflows

  • Install steps for apt, dnf, and zypper

Note: AI is powerful but fallible. Always review what it suggests—especially before running anything that writes or deletes data.

Why AI belongs in your shell

  • Text in, text out: The CLI is a perfect fit for LLMs. You’re already working with text—commands, logs, scripts, diffs.

  • Less context switching: Stay in Bash, keep state (env vars, paths), and immediately act on results.

  • Privacy/air‑gapped options: Run local models when logs or code can’t leave the machine.

  • Reproducible workflows: Save prompts and outputs as scripts or docs for the team.

Quick setup: prerequisites and backends

You can use either:

  • A cloud model (OpenAI) via curl (simple to start), or

  • A local model via Ollama (runs on your machine)

We’ll use curl and jq to talk to APIs and parse responses. For optional CLI tooling, we’ll use pipx.

Install prerequisites:

  • Ubuntu/Debian (apt):

    sudo apt update
sudo apt install -y curl jq pipx git
pipx ensurepath

  • Fedora/RHEL (dnf):

    sudo dnf install -y curl jq pipx git
pipx ensurepath

  • openSUSE (zypper):

    sudo zypper refresh
sudo zypper install -y curl jq pipx git
pipx ensurepath

Option A: Cloud backend (OpenAI)

  1. Set your API key:

    export OPENAI_API_KEY="sk-...yourkey..."

    Add it to ~/.bashrc (or ~/.bash_profile) to persist:

    echo 'export OPENAI_API_KEY="sk-...yourkey..."' >> ~/.bashrc

  2. Choose a model (example):

    export OPENAI_MODEL="gpt-4o-mini"

    Add:

    echo 'export OPENAI_MODEL="gpt-4o-mini"' >> ~/.bashrc

  3. Select backend:

    export AI_BACKEND="openai"
echo 'export AI_BACKEND="openai"' >> ~/.bashrc

(Optional) Install the OpenAI CLI with pipx:

pipx install openai

Option B: Local backend (Ollama)

  1. Install Ollama (creates a systemd service on most distros): curl -fsSL https://ollama.com/install.sh | sh
  2. Start the service if not already running: sudo systemctl enable --now ollama Or foreground: ollama serve
  3. Pull a model (example: Llama 3): ollama pull llama3
  4. Set backend and model: export AI_BACKEND="ollama" export OLLAMA_MODEL="llama3" echo 'export AI_BACKEND="ollama"' >> ~/.bashrc echo 'export OLLAMA_MODEL="llama3"' >> ~/.bashrc

Drop‑in Bash helpers

Paste these functions into ~/.bashrc, then source ~/.bashrc.

Base functions for calling AI:

ai_raw() {
  local prompt="$1"
  local system="${AI_SYSTEM_PROMPT:-You are a concise terminal assistant for Linux. Be accurate and brief.}"
  if [[ "${AI_BACKEND:-openai}" == "openai" ]]; then
    : "${OPENAI_API_KEY:?Set OPENAI_API_KEY for OpenAI backend}"
    curl -sS https://api.openai.com/v1/chat/completions \
      -H "Authorization: Bearer $OPENAI_API_KEY" \
      -H "Content-Type: application/json" \
      -d "$(jq -n \
        --arg m "${OPENAI_MODEL:-gpt-4o-mini}" \
        --arg sys "$system" \
        --arg usr "$prompt" \
        '{model:$m,messages:[{role:"system",content:$sys},{role:"user",content:$usr}]}')"
  else
    curl -sS http://localhost:11434/api/chat \
      -H "Content-Type: application/json" \
      -d "$(jq -n \
        --arg m "${OLLAMA_MODEL:-llama3}" \
        --arg sys "$system" \
        --arg usr "$prompt" \
        '{model:$m,stream:false,messages:[{role:"system",content:$sys},{role:"user",content:$usr}]}')"
  fi
}

ai() {
  # Print only assistant text content; works for both backends
  ai_raw "$*" | jq -r '.choices[0].message.content // .message.content'
}

aip() {
  # Read stdin and include it in the prompt
  local instruction="$*"
  local input; input="$(cat)"
  ai "$instruction

Input:

$input ```" }

strip_fences() { # Remove triple-backtick code fences if present sed -e 's/^.*$//' -e 's/^$//' -e '/^$/N;/^\n$/D' }


Safety‑first command generator and runner:

ai-cmd() { local query="$*" local sys='You are a Bash expert on Linux. Output ONE shell command only. Prefer safe flags. If the task could be destructive (e.g., rm, dd, mkfs), output a commented command starting with "# " and then a one-line caution.' AI_SYSTEM_PROMPT="$sys" ai "$query" | strip_fences }

ai-cmd-run() { local suggestion suggestion="$(ai-cmd "$")" || return 1 printf 'AI suggests:\n%s\n' "$suggestion" read -r -p "Run it? [y/N] " ans [[ "$ans" =~ ^[Yy]$ ]] || return 0 # Refuse to run lines that start with a comment (AI marked as dangerous) if grep -qE '^[[:space:]]#' <<<"$suggestion"; then echo "Refusing to run commented/destructive command. Edit manually if you accept the risk." return 1 fi eval "$suggestion" }


Explainers and summarizers:

ai-explain() { if [ -t 0 ]; then ai "Explain this Bash command step by step for Linux, including flags, edge cases, and safer alternatives:

$*" else local piped; piped="$(cat)" ai "Explain this Bash command step by step. Then analyze the piped input for pitfalls:

Command: $*

Piped input (truncated to context): $piped" fi }

ai-summarize-logs() { aip "Summarize key issues, error counts, time spans, and likely root causes. Output concise bullet points." }

ai-json() { # Ask AI to return machine-readable JSON; then pretty-print with jq aip "Extract structured JSON only (no commentary) summarizing issues with keys: summary, top_errors (map of error->count), suggestions (array). Return strictly valid JSON." \ | strip_fences | jq . }


---

## 5 actionable ways to use AI in your terminal today

### 1) Turn plain English into a safe, reviewable shell command
Describe what you want; get a single command back. Review and run with confirmation.

Example:

ai-cmd "sync my ~/Projects folder to /mnt/backup keeping permissions and showing progress"


Or run with a guard:

ai-cmd-run "find and compress all *.log files older than 14 days in /var/log into a dated tar.gz"


Tip: If the result includes a leading `#`, the AI flagged it as potentially destructive. The runner won’t execute it unless you edit manually.

---

### 2) Explain any pipeline, option by option
Stuck on a dense one‑liner from a coworker or StackOverflow? Get a quick breakdown.

Explain a command:

ai-explain 'find /var/log -type f -name "*.log" -mtime +7 -print0 | xargs -0 gzip -9'


Explain with context from stdin:

journalctl -u sshd -n 100 --no-pager | ai-explain 'grep "Failed password"'


---

### 3) Summarize gnarly logs into bite‑sized insights
Pipe logs directly for quick triage.

High‑level bullets:

journalctl -u nginx -n 500 --no-pager | ai-summarize-logs


Structured JSON for dashboards:

journalctl -p err -n 1000 --no-pager | ai-json | jq '.top_errors | to_entries | sort_by(-.value)[:5]'


Local‑only? Set `AI_BACKEND="ollama"` and keep logs on the box.

---

### 4) Generate awk/sed/regex one‑liners—then preview safely
Let AI craft the line, you control execution.

Generate without running:

ai-cmd 'awk one-liner to compute average response time from column 5 in access.tsv, skipping headers'


Preview on a sample:

cmd="$(ai-cmd 'sed command to replace IPv4 addresses in input with [REDACTED]')" printf 'Suggestion:\n%s\n' "$cmd" head -n 20 access.log | bash -c "$cmd"


Only run on full data once you like the preview.

---

### 5) Write better Git commit messages from diffs
Turn diffs into concise, conventional commits.

git diff --staged | aip "Write a single-line Conventional Commit message (type: scope): summary. Keep it under 70 chars."


To automate:

ai-commit() { local msg msg="$(git diff --staged | aip "Write a short Conventional Commit message (type: scope): summary, under 70 chars. No extra text.")" msg="$(echo "$msg" | strip_fences | head -n1)" git commit -m "$msg" } ```

Real‑world examples

  • Back up a directory with progress and permissions:

    ai-cmd-run "rsync -aP ~/data to /mnt/backup, exclude node_modules and .git"

  • Find why SSH logins are failing:

    journalctl -u sshd -n 2000 --no-pager | ai-summarize-logs

  • Explain a risky command before running it:

    ai-explain 'dd if=/dev/zero of=/dev/sdb bs=1M status=progress'

  • Extract a 5‑line summary of an incident:

    grep -E "ERROR|WARN" app.log | tail -n 1000 | ai-summarize-logs

Tips for safer, happier AI in Bash

  • Keep ai-cmd and ai-cmd-run separate: always review first.

  • Prefer local models for sensitive data (set AI_BACKEND="ollama").

  • Save good prompts in dotfiles; consistency beats re‑inventing.

  • Validate outputs with shellcheck, set -euo pipefail, and small test samples.

  • Strip code fences before execution (already handled by strip_fences).

Troubleshooting

  • “Command not found: jq/curl/pipx”

    • apt:
    sudo apt install -y jq curl pipx
    • dnf:
    sudo dnf install -y jq curl pipx
    • zypper:
    sudo zypper install -y jq curl pipx

  • Ollama not responding:

    systemctl status ollama
sudo systemctl enable --now ollama
curl -sS http://localhost:11434/api/tags

  • OpenAI 401/403:

    • Ensure OPENAI_API_KEY is set and valid.
    • Check your org/project permissions and model name.

Conclusion and next steps

You don’t need to bounce between a browser and your shell to get AI help. With a few small functions and either a cloud key or a local model, you can:

  • Generate safe, reviewable commands

  • Explain complex one‑liners

  • Summarize logs and diffs directly in Bash

Next steps: 1. Paste the helpers into ~/.bashrc and pick your backend (openai or ollama). 2. Try one example from each section on real work. 3. Evolve the prompts to match your team’s style—and check them into your dotfiles repo.

If you want a follow‑up post with Zsh/Fish versions or fzf integration, let me know what you’d like to build next!

Related posts