Evangelos Lamprou | Til

Emailing yourself command output with mutt

2025-12-27T00:00:00+00:00

mutt reads the message body from stdin, so you can email yourself (or anyone else) the output of any command:

cmd | mutt -s "$subject" "$email"

Sending a quick note:

echo "$x $y $z" | mutt -s "Reminder" "$email"

Sending a morning reminder of active tasks, run as a cron job:

task active | mutt -s "Tasks" "$email"

Writing weekly reports from Taskwarrior with an LLM

2025-03-29T00:00:00+00:00

For weekly update meetings, Taskwarrior already knows what you did. This pipeline exports last week’s completed tasks as JSON, uses jq to pull out each .description, and asks llm to write the report:

task status:completed end.after:today-7d export |
jq '.[] | .description' |
llm -s 'Generate a report based on these tasks.'

Naming image files with a local vision model

2025-03-29T00:00:00+00:00

Downloaded images tend to have useless names:

$ ls
1672714705640839.png 1689964585834142.png 2.jpg

ollama with the moondream vision model is small enough to run quickly on a laptop. This asks it for a title for every .jpg in the current directory and turns each title into a plausible filename:

find . -name "*.jpg" |
xargs -I{} ollama run moondream "Title for this: {}" |
tr ' ' '_' | sed 's/$/\.jpg/'

Some of the (slightly truncated) results: A_green_dragon_with_wings_and_a_tail.jpg , A_painting_of_a_serene_landscape.jpg , urns_of_stone_red_car_in_foreground.jpg .

Taking notes on talk videos with yt-dlp and llm

2025-03-29T00:00:00+00:00

yt-dlp can download just a video’s subtitles, which you can pipe through llm to get notes, and then straight into a new zk note to review and expand later:

yt-dlp --no-download --write-subs --output "$OUT" "$URL"
cat "$OUT" | llm -s "Create notes" | zk new -i

Generating playlists by interpolating audio embeddings

2025-03-29T00:00:00+00:00

A model that understands audio can embed a music collection into a space where similar songs sit close together. Interpolating between two songs in that space gives you a path between them, which is a playlist that transitions smoothly.

With llm and the llm-clap plugin, embed your collection ($MC) with the CLAP model. This stores every song and its embedding in a local embeddings.db:

llm embed-multi -m clap songs --files $MC '*'

The llm-interpolate plugin then returns the points between a start and an end song. This makes a 5-song .m3u playlist from PacifyHer.wav to redrum.wav:

llm interpolate songs "PacifyHer" "redrum" -n 5 | jq .[] > playlist.m3u

Turning GitHub issues into Taskwarrior tasks

2025-02-18T00:00:00+00:00

gh can list a repository’s issues as JSON, and jq can flatten that into one issue per line, which makes it easy to feed into Taskwarrior.

gh issue ls --json title,url outputs an array:

[
  {"title": "An Issue", "url": "https://github.com/user/repo/issues/1"},
  {"title": "Another Issue", "url": "https://github.com/user/repo/issues/2"}
]

jq -c '.[]' turns it into one compact object per line:

{"title":"An Issue","url":"https://github.com/user/repo/issues/1"}
{"title":"Another Issue","url":"https://github.com/user/repo/issues/2"}

Then loop over the lines and task add each one:

while read -r issue; do
  title=$(jq -r '.title' <<< "$issue")
  url=$(jq -r '.url' <<< "$issue")
  task add "$title" url:"$url"
done < <(gh issue ls --json title,url | jq -c '.[]')

url here is a user-defined attribute (UDA), so task info shows the link:

$ task info 1
Name          Value
ID            1
Description   An Issue
Status        Pending
URL           https://github.com/user/repo/issues/1

Adding labels to the --json fields lets you turn issue labels into task tags too.

Converting a meeting time to your local timezone

2023-07-02T00:00:00+00:00

When an email sets a meeting for “12PM noon EDT”, GNU date will convert it to your local timezone:

$ date --date="12 PM EDT"
Sat Jul  1 07:00:00 PM EEST 2023

MCI commands are defined by a command table

2023-04-11T00:00:00+00:00

MCI (Media Control Interface) is an old Windows API for controlling media devices with high-level command strings like play file.wav from 0 to 100. The general shape is:

command  [parameters ...]

There is no fixed list of commands. Instead, a command table defines each command and its arguments, and the parser reads it, so new commands can be added by just editing the table. Here’s part of the open entry in ScummVM’s in-memory command table:

static CmdTableRow table[] = {
  {"open"            ,MCI_OPEN      ,0          ,MCI_COMMAND_HEAD },
  {""                ,MCI_INTEGER   ,0          ,MCI_RETURN }      ,
  {"notify"          ,0x00000001L   ,-1         ,MCI_FLAG }        ,
  {"wait"            ,0x00000002L   ,-1         ,MCI_FLAG }        ,
  {"type"            ,0x00002000L   ,-1         ,MCI_STRING }      ,
  {"element"         ,0x00000200L   ,-1         ,MCI_STRING }      ,
  {"alias"           ,0x00000400L   ,-1         ,MCI_STRING }      ,
  {"shareable"       ,0x00000100L   ,-1         ,MCI_FLAG }        ,
  {""                ,0x00000000L   ,-1         ,MCI_END_COMMAND } ,
  // ...

IBM patented this parsing mechanism. The patent goes as far as specifying that tokens are kept in a linked list rather than an array, probably for low-memory devices, and that the parsed arguments end up in a byte array at fixed offsets.

Wine’s MCI parser does the same thing: it parses the command strings a Win32 program sends and translates them into calls to Linux sound and video APIs. ScummVM does the same with its own APIs, but stores each command’s arguments in a hash table instead of a byte array.