Blog — George Mishurovsky: posts tagged shell

jq is Wonderful!

Mon, 30 Mar 2026 11:05:29 +0200

Linux is a brilliant OS — because it has a great set of tools to work with text files! Today I’ve tried to use jq to come up with a little wonder I find worth sharing. Might be it will make your life simpler too.

Suppose you have a chat-export.json with your monthly spendings mixed with other messages like this:

JSON

[
  {
    "id": 139,
    "message": "18 pizza in Pizza World",
    "chat": {
      "id": 123,
    },
    "date": "2026-02-26 10:15:00+00:00"
    // ...30 fields more
  },
  {
    "id": 140,
    "message": "120 bills",
    "chat": {
      "id": 123,
    },
    "date": "2026-03-02 14:30:00+00:00"
  },
  {
    "id": 141,
    "message": "Some message from another chat",
    "chat": {
      "id": 140,
    },
    "date": "2026-03-02 19:20:00+00:00"
  },
  {
    "id": 142,
    "message": "3.5 coffee in Cream",
    "chat": {
      "id": 123,
    },
    "date": "2026-03-08 08:45:00+00:00"
  },
  {
    "id": 143,
    "message": "Another unrelated message",
    "chat": {
      "id": 156,
    },
    "date": "2026-03-11 12:05:00+00:00"
  },
  // ...1000 entries more
]

How can you calculate your spendings in March *fast*? jq to the rescue!

Shell

jq '[ .[]                       # iterate over array items
  | select(.chat.id == 123)     # filter the ones from budget chat
  | select(.date | startswith("2026-03")) # filter the ones from March
  | .message                    # extract message text
  | gsub("[^0-9.]"; "")         # leave only numeric symbols and dots
  | tonumber                    # convert text to numbers
] | add' chat-export.json       # get the sum!

Or as a one-liner:

Shell

jq '[ .[] | select(.chat.id == 123) | select(.date | startswith("2026-03")) | .message | gsub("[^0-9.]"; "") | tonumber ] | add' chat-export.json

As short as it can get, clear, easy to use — and no software involved apart from utilities that come with the system. Shiny! ✨

Renaming Entities Project-Wide with find, grep, sed, and rename

Mon, 20 Oct 2025 15:07:33 +0200

There are times in software projects when a big shift happens in domain representation. This results in changes of project structure, class responsibilities, and occasionally, requires bulk renames of entities across the whole codebase.

Imagine we need to rename every Employee to Worker. This change should affect both file paths and textual occurrences throughout the project.

Renaming may sound like a simple problem: assuming there are no external dependencies using the target name, we just need to rename all occurrences of it inside a repository. But there multiple caveats:

We must rename both file names and folder names.
We must rename all code and text occurrences.
Casing must be preserved: Employee → Worker, and employee → worker.
Both plain and compound usages must be properly renamed: createEmployee → createWorker.
Non-code, non-document files must not be affected (consider binary files which by coincidence might have an ...employee... fragment inside).
There are folders or files which we would want to omit from renaming (e. g., .git).
No IDE provides such functionality, so we cannot rely on existing solutions.

I will address all these challenges in a solution below, but there is an important complexity that cannot be tackled with automation. If by any chance your code depends on a library with the target name (e. g., employee.js) or uses exports from a library containing the target name (import type { valuableEmployeee } from ‘employee-js’), you’ll have to resolve issues manually after renaming.

Reviewing Expected Changes

First, remove any folders and files that are recreated during project builds or setup: build/, dist/, node_modules/, .storybook-static/, etc. This step isn’t strictly necessary, but it can help iterate faster if commands encounter errors.

Now, let’s start with renaming text occurrences by listing all files that might get affected with find command. Here I am using -iname for case-insensitive search and `-not -path ‘’` syntax to exclude folders we need to protect from changes.

Shell

find . -not -path '*/.*' -not -path 'src/protected' -iname '*employee*'

Revise the output: make sure it does not contain folders or files you do not want to be changed.

Then, let’s see which text occurrences inside our files will be affected. Same approach: case-insensitive search in all files, excluding protected directories or files.

Shell

grep -RIn -i --exclude-dir='*/.*' --exclude-dir='src/protected' 'employee' .

In the output you’ll see all lines containing the target name. Revise all them carefully: if you want to protect some names from changes, you might want to add file names to exclusion, or rename such occurrences manually to some special value (e. g. em#plo#yee), so you can revert it later.

Renaming Text Occurences

Now we can rename all text occurrences, handling separately each casing. It will require some sed magic:

Shell

LC_CTYPE=UTF-8 find . -type f \
  -not -path '*/.*' \
  \( -name '*.ts' -o -name '*.tsx' -o -name '*.js' -o -name '*.json' \) \
  -exec sed -i 's/Employee/Worker/g; s/employee/worker/g' {} +

There are two important points here. First, LC_CTYPE=UTF-8 allows us to treat all file characters as UTF-8, even if the situation is different. Without it, sed stops when encounters non-UTF-8 characters. Second, we use -o -name ‘*.ext’ syntax to list file extensions to be affected. This prevents accidental changes of binary or image file contents.

Renaming Paths

Hopefully, file content renaming finished successfully. From here we will proceed with renaming of file and folder names. For this we will use rename command ingesting find output:

Shell

find . -not -path '*/.*' -depth -name '*Employee*' \
  -exec rename 's/Employee/Worker/g' {} +
find . -not -path '*/.*' -depth -name '*employee*' \
  -exec rename 's/employee/worker/g' {} +

These commands might produce warnings. If you have file paths that include multiple occurrences of the target name, the renames will be performed only for the first one, so you will have to run the commands multiple times until the paths are fully renamed.

And that’s it! ✨
If you created any specially-renamed entities, rename them back manually. Then run git add and git commit — git should detect all path renames automatically.

How to Delete All Local Git Branches in One Command

Thu, 28 Aug 2025 13:46:06 +0200

First, checkout to main (or any other branch you want to clear from upstream branches).

Now, let’s build the command, step by step.

Check which branches were merged to the current branch:

Shell

git branch --merged

Filter out current branch from the output – it is marked by an asterisk (*):

Shell

git branch --merged | grep -v \*

Turn the columnar output into a space-separated string:

Shell

git branch --merged | grep -v \* | xargs

Feed these arguments to the deletion command (passed in the second argument of xargs):

Shell

git branch --merged | grep -v \* | xargs git branch -D

How to Recall Your Google Meets Fast

Sat, 16 Aug 2025 15:25:27 +0200

I have to confess. I am a sinner — I constantly forget to log my time spent on tasks! I postpone this demanding chore for a week, until our PM comes bashing my door (and I work remotely!): “Please log your time, we need to create reports!” And here lies the problem: usually, I can hardly remember even what happened yesterday, let alone the whole week. I believe I am not alone here.

Alright, so now I need to log my work time for the week. I can track code contributions by commit dates, but how do I log meeting times? A common way to do this is to sweep through emails, Slack messages and meeting notes, but it is chaotic and time-consuming. If you use Google Meet, there is a much more straightforward way — Google Takeout!

Google Takeout is a service that allows you to download all data Google keeps about your account. This is a very interesting yet terrifying resource: you’ll find data from over 60 different services, some of which may keep gigabytes of your data! But for our current goal, we only need Google Meet data.

What to do

First, visit https://takeout.google.com/ from a work account. Deselect all checkboxes, then find and mark Google Meet. Scroll to the bottom of the page, and click primary-colored buttons a couple of times. Google will prepare data export and will send a link to your email. Use it to download a zip archive with data and unpack it.

When you get to Google Takeout page, deselect all checkboxes and then find and mark Google Meet.

Click “Next step”, then “Create export” — Google will send a report to your account email in a minute.

The downloaded folder has a nested structure of ./Takeout/Google Meet/ConferenceHistory with two .csv files inside. We will need only conference_history_records.csv. It is a large csv file with about 20 columns, holding information about all meets for your account. Let’s tidy it up with some command line magic to get a convenient output:

Shell

awk -F ',' '{print $5 "\t" $10 "\t" $12}' "~/Downloads/Takeout/Google Meet/ConferenceHistory/conference_history_records.csv" | head -n 20 | column -ts $'\t'

This command parses the csv and outputs only important data in a columnar view: meeting code (the same one used in Google Meet Links), date and time of the meet and its duration.

Meeting Code  Start Time               Duration
rst-uvwx-yza  2025-08-17 14:14:14 UTC  1:07:18
fgh-ijkl-mno  2025-08-16 06:36:12 UTC  0:23:57
vwx-yzab-cde  2025-08-15 17:20:33 UTC  0:41:03
klm-nopq-rst  2025-08-14 09:09:09 UTC  1:15:42
yza-bcde-fgh  2025-08-13 20:48:06 UTC  0:55:56
hij-klmn-opq  2025-08-12 07:02:08 UTC  0:17:15
opq-rstu-vwx  2025-08-11 15:33:54 UTC  0:34:29
tuv-wxyz-abc  2025-08-10 05:44:21 UTC  1:49:37
def-ghij-klm  2025-08-09 19:59:59 UTC  0:26:04
uvw-xyza-bcd  2025-08-08 11:11:11 UTC  0:09:48

Now it is much easier to recall which meetings they were and how long they lasted. Unfortunately, this file does not provide meeting names — but now retrieving them is easy: just copy-paste meeting code into your gmail search box, and you will find your invitation email with all the details.

This way I manage to save myself some 15 to 20 minutes each week. I hope this trick helps you, too.

Shell Configs for Better Command History Search

Thu, 07 Aug 2025 12:54:33 +0200

In continuation of my previous post, “How to View Past Terminal Commands: from Simple to Robust”, I want to share shell config settings that help finding commands faster, while also looking for them much more further in the past.

Increase History Limits

First, HISTSIZE and HISTFILESIZE. These settings control how many past commands are stored in session memory and in the history file, respectively. Their defaults are 1000 commands for HISTSIZE and 2000 commands for HISTFILESIZE.

This is way too low for modern computers. If an average command length is 20 characters, then history settings limit us to only 40 KB in RAM and 80 KB on disk. Also there is no real benefit to storing fewer commands in memory: if a history entry exists, you should be able to access it using history command without additional tricks.

Let’s increase the limits:

Shell

# bash
HISTSIZE=50000
HISTFILESIZE=50000

# zsh
HISTSIZE=50000
SAVEHIST=50000

Remove Duplicates in Search

Now, let’s compress history entries. When I lookup commands using reverse search (Ctrl+R), I do not want to see duplicates like docker build. Let’s keep only the most recent copy of each command:

Shell

# bash
HISTCONTROL=ignoredups:erasedups

# zsh
setopt HIST_IGNORE_ALL_DUPS

Ignore Noise in History

When I use command search using arrow keys, I want to get quicker to useful commands, rather than wasting time and attention to common simple commands, such as ls or cd. Let’s prevent them from being saved at all:

Shell

# bash
HISTIGNORE="ls:cd:cd -:pwd:exit:clear"

# zsh
HIST_SKIP_PATTERN='^(cd|ls|pwd|clear|exit)(\s|$)'

Sync History Across Sessions

By default, history is saved only when a session closes. Let’s fix it: the terminal should append new commands and make them accessible in all open sessions immediately:

Shell

# bash
PROMPT_COMMAND='history -a; history -n'
shopt -s histappend

# zsh
setopt SHARE_HISTORY
setopt APPEND_HISTORY
setopt INC_APPEND_HISTORY

Final Setup

Now we are good! Below are full settings for both bash and zsh. Do not forget to run source ~/.bashrc or source ~/.zshrc after you make the changes.

Shell

# bash
HISTSIZE=50000
HISTFILESIZE=50000

HISTCONTROL=ignoredups:erasedups
HISTIGNORE="ls:cd:cd -:pwd:exit:clear"

PROMPT_COMMAND='history -a; history -n; $PROMPT_COMMAND'
shopt -s histappend

Shell

# zsh
HISTSIZE=50000
SAVEHIST=50000

setopt HIST_IGNORE_ALL_DUPS
HIST_SKIP_PATTERN='^(cd|ls|pwd|clear|exit)(\s|$)'

setopt APPEND_HISTORY
setopt SHARE_HISTORY
setopt INC_APPEND_HISTORY

Happy command searching!

P.S. Want Full Command Logging?

If you want to keep full command history, you are not constrained to inefficient search. You still can apply all the changes above, but additionally configure the shell to store full log in a separate file:

Shell

# bash
export LOGFILE=~/.full_bash_history.log
PROMPT_COMMAND='
  history -a
  history -n
  this_command=$(history 1 | sed "s/^[ ]*[0-9]*[ ]*//")
  echo "$(date "+%Y-%m-%d %H:%M:%S")  $this_command" >> "$LOGFILE"
'

# zsh
function preexec() {
  local LOGFILE=~/.full_zsh_history.log
  echo "$(date '+%Y-%m-%d %H:%M:%S')  $1" >> "$LOGFILE"
}

How to View Past Terminal Commands — from Simple to Robust

Sun, 03 Aug 2025 14:18:24 +0200

Suppose you want to re-run some shell command you used ten days ago. It is a complex one; you do not remember exact flags and argument values, and it would take a long time to recall an exact text. What can you do?

1. The upwards arrow

Majority of devs working with command line knows it. Press “up” to see a previous command, press “down” for a next command, press “Ctrl+C” to drop whatever is in the prompt and start fresh.

This approach works, but gets very tedious when you need to find a command you used last week or last month. Once more than ten or twenty commands have passed, scrolling through them becomes tedious.

2. Terminal history file

All the commands you enter into a terminal get stored in .bash_history file (or .zsh_history if you are on Mac) up to a certain limit. Thus, you can run:

Shell

cat ~/.bash_history # output all into the terminal
less ~/.bash_history # or use any text viewer
tail -n 20 ~/.bash_history # or observe only the most recent n lines
cat ~/.bash_history | grep whatever # to search for specific patterns

This method gives you full access to your history file, and lets you search more flexibly.

3. history command

Almost the same as using the history file directly: you get a list commands, but now it is numbered.

Shell

history -20 # show the last 20 commands
history -500 | grep ssh # search for a specific patter in a command
!780 # execute command with order number 780

But there is one important difference from direct usage of .bash_history:

history command uses the last HISTSIZE history entries (default 1000)
.bash_history file uses the last HISTFILESIZE entries (default 2000)
So, if your command was run a really long time ago, history may not find it, but direct inspection of .bash_history can do.

4. fc -l command

This command behaves very similar to history, with an additional ability to display ranges of command numbers::

Shell

fc -l -20 # show the last 20 commands
fc -l 100 150 # show commands 100 to 150

5. Reverse-i-search

This is the most powerful approach. Press “Ctrl+R” to enter reverse incremental search mode. Initially you get no output; start writing any part of a command you remember, e. g. ssh or input.json or -n 10 — and you will see the first full command entry with that match!

From there, you can:

Press “Enter” to execute the command immediately
Use left/right arrow keys to move within a command to edit it, then press “Enter” to execute
Press “Ctrl+R” again to go to the next, older match
Press “Ctrl+S” to go to the previous, newer match (see comment below)
Press up-down arrows to view to nearby entries in history around the match
Press “Ctrl+C” or “Ctrl+G” to exit the search

On many systems “Ctrl+S” shortcut will not work, as it is prioritized to pause terminal output (press “Ctrl+Q” to resume). To make it work for reverse-i-search, add stty -ixon to your shell config. It will disable “Ctrl+S” / “Ctrl+Q” shortcuts for terminal flow control:

Shell

echo "stty -ixon" >> ~/.bashrc
source ~/.bashrc

Happy command line manipulation!

💡 This post has a second part: Shell Configs for Better Command History Search