This bot gives advice about how to make layouts in WordPress using the stock tools and features. More on this later, on to the Thaura Projects settings.

Thaura Projects is a feature to allow you to create chatbots (and other interactive tools).

To create a new Project, click on Project in the navigation, and then “+” in the upper right corner.

Fill in the form with:

Then save it, and go to the Project. In the upper right, click the triple-dot menu and Edit.

Add:

This is a screenshot of the dialog box where you paste in the prompts.

The post Thaura & WordPress: layout advice chatbot first appeared on 🍙.

I use three kinds of timesheets – paper, Toggl, and shell history. I’ve always used a combination of tools, because, for example, I forget to click the “off” button on Toggle. Preparing accurate timesheets is sometimes a process of finding all this history, and identifying the work intervals.

I added to this collection of methods by creating a “clock in” command with this prompt:

create a CLI command, “clock”, that helps to keep track of time worked. it works in tandem with the .zsh_history, which is the source of truth, because running the program will show up in the history. when user types “clock in”, the program checks .zsh_history, and reports the last work interval. work intervals are the time periods between “clock in” and “clock out” commands. when the user types “clock out”, it reports the length of the work interval that has now terminated. when the user types “clock” without an argument, it reports all the work intervals for the last 35 days.

The “clock” command produces reports that look like this:

➜  bin clock
work intervals, last 35 days
--------------------------------------------------------------------------
  1. 2026-08-24 13:48:10  ->  2026-08-24 13:48:18   [8s]
  2. 2026-08-24 13:49:34  ->  2026-08-24 13:50:46   [1m 12s]
  3. 2026-08-24 13:50:56  ->  2026-08-24 13:51:02   [6s]
  4. 2026-08-24 13:51:29  ->  2026-08-24 13:51:44   [15s]
--------------------------------------------------------------------------
total: 4 interval(s), 1m 41s worked

currently CLOCKED IN since 2026-08-24 13:53:24 (16m 02s so far)

Here’s the command it produced

#!/usr/bin/env python3
"""clock — track work intervals using $ZDOTDIR/.zsh_history as the source of truth.

Usage:
  clock in     Record a punch-in (the command lands in history automatically).
               Reports the last completed work interval for context.
  clock out    Close the open interval started by the most recent "clock in".
               Reports its length.
  clock        Report all work intervals from the last 35 days, plus totals.
"""

import os
import re
import sys
from datetime import datetime, timedelta

HISTORY_FILE = os.path.expanduser(os.environ.get("HISTFILE", "~/.zsh_history"))
WINDOW_DAYS = 35

# Matches zsh extended-history lines: ": <epoch>:<duration>;command"
LINE_RE = re.compile(r"^: (\d+):\d+;(.*)$")


LOCAL_TZ = datetime.now().astimezone().tzinfo


def dt(ts):
    return datetime.fromtimestamp(ts, tz=LOCAL_TZ)


def parse_history(path):
    """Return [(timestamp, command)] parsed from the history file."""
    entries = []
    try:
        with open(path, encoding="utf-8", errors="replace") as fh:
            for raw in fh:
                m = LINE_RE.match(raw.rstrip("\n"))
                if m:
                    ts = int(m.group(1))
                    cmd = m.group(2).strip()
                    # Skip continuation-line artifacts that carry no timestamp.
                    entries.append((ts, cmd))
    except FileNotFoundError:
        print(f"error: history file not found: {path}", file=sys.stderr)
        sys.exit(1)
    return entries


def is_clock(cmd, verb=None):
    """True if this history entry is a `clock [verb]` invocation."""
    parts = cmd.split(None, 1)
    if not parts or parts[0] != "clock":
        return False
    rest = parts[1].strip() if len(parts) > 1 else ""
    if verb is None:
        return rest == ""
    return rest == verb


def find_punches(entries):
    """Pair clock punches from history into work intervals.

    Returns (intervals, open_start) where intervals is a list of
    (start_dt, end_dt) tuples oldest-first, and open_start is the
    start time of an unclosed interval, or None.
    """
    events = []
    for ts, c in entries:
        verb = None
        if is_clock(c, "in"):
            verb = "in"
        elif is_clock(c, "out"):
            verb = "out"
        if verb is not None:
            events.append((ts, verb))
    events.sort(key=lambda ev: ev[0])

    # Pair punches left-to-right: each "in" opens an interval, closed by the
    # next "out". A stray "out" with nothing open is ignored; a stray "in"
    # leaves the interval open.
    #
    # Note on the current invocation: zsh writes the running command's own
    # history entry at varying times depending on how the shell was started,
    # so we deliberately do NOT special-case it. For `clock in` the stale
    # state is harmless (it just prints "already clocked in" once). For
    # `clock out`, if the matching `clock in` hasn't been flushed yet, the
    # close fails cleanly — run `clock out` again a moment later.
    intervals = []
    open_start = None
    for ts, verb in events:
        if verb == "in":
            open_start = dt(ts)
        else:
            if open_start is not None:
                intervals.append((open_start, dt(ts)))
                open_start = None
    return intervals, open_start


def fmt_duration(seconds):
    seconds = int(round(seconds))
    h, rem = divmod(abs(seconds), 3600)
    m, s = divmod(rem, 60)
    sign = "-" if seconds < 0 else ""
    if h:
        return f"{sign}{h}h {m:02d}m {s:02d}s"
    if m:
        return f"{sign}{m}m {s:02d}s"
    return f"{sign}{s}s"


def fmt_stamp(dt):
    return dt.strftime("%Y-%m-%d %H:%M:%S")


def report_intervals(intervals, title):
    total = sum((e - s).total_seconds() for s, e in intervals)
    print(title)
    print("-" * 74)
    if not intervals:
        print("(no complete work intervals)")
    for idx, (s, e) in enumerate(intervals, 1):
        dur = (e - s).total_seconds()
        print(f"{idx:>3}. {fmt_stamp(s)}  ->  {fmt_stamp(e)}   [{fmt_duration(dur)}]")
    if intervals:
        print("-" * 74)
        print(f"total: {len(intervals)} interval(s), {fmt_duration(total)} worked")


def main():
    args = sys.argv[1:]
    if len(args) > 1 or args and args[0] not in ("in", "out"):
        print(__doc__.strip(), file=sys.stderr)
        sys.exit(2)

    now = datetime.now().astimezone()
    entries = parse_history(HISTORY_FILE)
    intervals, open_start = find_punches(entries)

    if not args:
        since = now - timedelta(days=WINDOW_DAYS)
        recent = [(s, e) for s, e in intervals if s >= since]
        report_intervals(recent, f"work intervals, last {WINDOW_DAYS} days")
        if open_start:
            elapsed = (now - open_start).total_seconds()
            print(f"\ncurrently CLOCKED IN since {fmt_stamp(open_start)} ({fmt_duration(elapsed)} so far)")
        elif recent:
            print("\nstatus: clocked out")
        return

    if args[0] == "in":
        if open_start:
            print(f"already clocked in since {fmt_stamp(open_start)} "
                  f"({fmt_duration((now - open_start).total_seconds())} so far)")
            print("use 'clock out' first if you meant to close that interval.")
            sys.exit(1)
        print(f"clocked in at {fmt_stamp(now)}")
        if intervals:
            ls, le = intervals[-1]
            print(f"last interval: {fmt_stamp(ls)} -> {fmt_stamp(le)} "
                  f"[{fmt_duration((le - ls).total_seconds())}]")
        return

    # clock out
    if not open_start:
        print("not clocked in — nothing to close.", file=sys.stderr)
        sys.exit(1)
    closed = (now - open_start).total_seconds()
    print(f"interval closed: {fmt_stamp(open_start)} -> {fmt_stamp(now)} "
          f"[{fmt_duration(closed)}]")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""clock — track work intervals using $ZDOTDIR/.zsh_history as the source of truth.

Usage:
  clock in     Record a punch-in (the command lands in history automatically).
               Reports the last completed work interval for context.
  clock out    Close the open interval started by the most recent "clock in".
               Reports its length.
  clock        Report all work intervals from the last 35 days, plus totals.
"""

import os
import re
import sys
from datetime import datetime, timedelta

HISTORY_FILE = os.path.expanduser(os.environ.get("HISTFILE", "~/.zsh_history"))
WINDOW_DAYS = 35

# Matches zsh extended-history lines: ": <epoch>:<duration>;command"
LINE_RE = re.compile(r"^: (\d+):\d+;(.*)$")


LOCAL_TZ = datetime.now().astimezone().tzinfo


def dt(ts):
    return datetime.fromtimestamp(ts, tz=LOCAL_TZ)


def parse_history(path):
    """Return [(timestamp, command)] parsed from the history file."""
    entries = []
    try:
        with open(path, encoding="utf-8", errors="replace") as fh:
            for raw in fh:
                m = LINE_RE.match(raw.rstrip("\n"))
                if m:
                    ts = int(m.group(1))
                    cmd = m.group(2).strip()
                    # Skip continuation-line artifacts that carry no timestamp.
                    entries.append((ts, cmd))
    except FileNotFoundError:
        print(f"error: history file not found: {path}", file=sys.stderr)
        sys.exit(1)
    return entries


def is_clock(cmd, verb=None):
    """True if this history entry is a `clock [verb]` invocation."""
    parts = cmd.split(None, 1)
    if not parts or parts[0] != "clock":
        return False
    rest = parts[1].strip() if len(parts) > 1 else ""
    if verb is None:
        return rest == ""
    return rest == verb


def find_punches(entries):
    """Pair clock punches from history into work intervals.

    Returns (intervals, open_start) where intervals is a list of
    (start_dt, end_dt) tuples oldest-first, and open_start is the
    start time of an unclosed interval, or None.
    """
    events = []
    for ts, c in entries:
        verb = None
        if is_clock(c, "in"):
            verb = "in"
        elif is_clock(c, "out"):
            verb = "out"
        if verb is not None:
            events.append((ts, verb))
    events.sort(key=lambda ev: ev[0])

    # Pair punches left-to-right: each "in" opens an interval, closed by the
    # next "out". A stray "out" with nothing open is ignored; a stray "in"
    # leaves the interval open.
    #
    # Note on the current invocation: zsh writes the running command's own
    # history entry at varying times depending on how the shell was started,
    # so we deliberately do NOT special-case it. For `clock in` the stale
    # state is harmless (it just prints "already clocked in" once). For
    # `clock out`, if the matching `clock in` hasn't been flushed yet, the
    # close fails cleanly — run `clock out` again a moment later.
    intervals = []
    open_start = None
    for ts, verb in events:
        if verb == "in":
            open_start = dt(ts)
        else:
            if open_start is not None:
                intervals.append((open_start, dt(ts)))
                open_start = None
    return intervals, open_start


def fmt_duration(seconds):
    seconds = int(round(seconds))
    h, rem = divmod(abs(seconds), 3600)
    m, s = divmod(rem, 60)
    sign = "-" if seconds < 0 else ""
    if h:
        return f"{sign}{h}h {m:02d}m {s:02d}s"
    if m:
        return f"{sign}{m}m {s:02d}s"
    return f"{sign}{s}s"


def fmt_stamp(dt):
    return dt.strftime("%Y-%m-%d %H:%M:%S")


def report_intervals(intervals, title):
    total = sum((e - s).total_seconds() for s, e in intervals)
    print(title)
    print("-" * 74)
    if not intervals:
        print("(no complete work intervals)")
    for idx, (s, e) in enumerate(intervals, 1):
        dur = (e - s).total_seconds()
        print(f"{idx:>3}. {fmt_stamp(s)}  ->  {fmt_stamp(e)}   [{fmt_duration(dur)}]")
    if intervals:
        print("-" * 74)
        print(f"total: {len(intervals)} interval(s), {fmt_duration(total)} worked")


def main():
    args = sys.argv[1:]
    if len(args) > 1 or args and args[0] not in ("in", "out"):
        print(__doc__.strip(), file=sys.stderr)
        sys.exit(2)

    now = datetime.now().astimezone()
    entries = parse_history(HISTORY_FILE)
    intervals, open_start = find_punches(entries)

    if not args:
        since = now - timedelta(days=WINDOW_DAYS)
        recent = [(s, e) for s, e in intervals if s >= since]
        report_intervals(recent, f"work intervals, last {WINDOW_DAYS} days")
        if open_start:
            elapsed = (now - open_start).total_seconds()
            print(f"\ncurrently CLOCKED IN since {fmt_stamp(open_start)} ({fmt_duration(elapsed)} so far)")
        elif recent:
            print("\nstatus: clocked out")
        return

    if args[0] == "in":
        if open_start:
            print(f"already clocked in since {fmt_stamp(open_start)} "
                  f"({fmt_duration((now - open_start).total_seconds())} so far)")
            print("use 'clock out' first if you meant to close that interval.")
            sys.exit(1)
        print(f"clocked in at {fmt_stamp(now)}")
        if intervals:
            ls, le = intervals[-1]
            print(f"last interval: {fmt_stamp(ls)} -> {fmt_stamp(le)} "
                  f"[{fmt_duration((le - ls).total_seconds())}]")
        return

    # clock out
    if not open_start:
        print("not clocked in — nothing to close.", file=sys.stderr)
        sys.exit(1)
    closed = (now - open_start).total_seconds()
    print(f"interval closed: {fmt_stamp(open_start)} -> {fmt_stamp(now)} "
          f"[{fmt_duration(closed)}]")


if __name__ == "__main__":
    main()

That single prompt produced the entire program, without any intervention on my part. (Getting to that prompt required a little research into .zsh_history logging, though.1) Watching it write the code was fascinating. It was testing use cases, testing how Zsh records history, adding useful messages.

I’ve only skimmed the code, and can’t say how good it is.

I wouldn’t have written it this way. I would have used grep.

Note

1. A long time ago, I created a text-based timesheet calculator. Then, I created a program called log_everything that would run on all my computers, and compile log files from command history, browser history, and other data sources. Writing a log importer for any existing log file was trivial. I think I was scanning mailbox files, too. I could get a comprehensive overview of personal activities from a single database. It was useful for seeing what work I’d done, but, it was creepy to spy on myself.

The post Thaura Work: time clock using .zsh_history first appeared on 🍙.

This document describes some of the architecture and some design decisions, and some prompts.

Thaura Work is a feature in the Thaura desktop app that allows the LLM to access your files. It’s a shell around OpenCode.

Here are some screenshots. First, the “user” side:

(I’m using the Regolith tiling window manager.) The leftmost pane is the web browser. The middle pane is Obsidian, displaying headlines from an RSS feed. The right pane is the graphical user interface that lets me put a URL into the system.

The most general use case is to find a web site or page, and copypaste the URL into the GUI, which then runs the program. If there’s an RSS feed, it’s downloaded, and if there are recent stories, they’re written out as a Markdown file.

Here is the “programmer” screen:

The left page shows the folder structure and programs — one is a double clickable icon that will launch the user interface. The middle pane shows the output from running run.py, the master command. The right pane shows Thaura Work.

Normally, I use tabs instead of panes. (The window manager is Regolith.)

The most common use cases here are:

• Running run.py bare, to process the inbox.
• Running run.py --refresh, to process known good URLs.
• Telling Thaura Work to write or debug code.
• Looking for program misbehavior in the folders.

Design Decisions

Thaura Work seemed to be choking on long source code, so I decided to build the system up as Python commands. To grow the program, I can add more commands, and call them from a “master control” program called run.py.

The program is basically a batch processor, which I’ll call a “workflow”.

Users provide URLs in text files, stdin, and command line args.

I decided NOT to use a database, but to use the file system like a database.

Data records are in small text files. Folders act as state buckets, and text files are moved (or read from and written) to folders.

You have an “inbox” folder. The run.py command processes it.

URL files get classified into “urls.bad” and “urls.good” by another command.

The system checks RSS feeds with another command, and the ones that have no data or stale data get put into “rssfeed.bad”.

Each stage in the process has its own command that writes data into these folders. That’s the workflow.

The data files should look like they move through the folders organized like this:

Example file in rssfeed.bad:

# RSS URL: https://www.pcgamer.com/feeds.xml
# Error: No recent articles found in past 24 hours
# Moved to rssfeed.bad: 2026-06-26T02:17:59.706051

Example file in url.good:

https://www.pcgamer.com https://www.pcgamer.com/feeds.xml

There’s not really any rhyme or reason to these formats. They just evolved, so they’ll need to be forced to converge onto a single format.

Initially, I imagined the URL files would just pass through these folders. What actually happened was, the data was transformed, so files were read and written into these folders.

Filenames are standardized and look like this: c9a9d5ad_www_kotaku_com.txt

That’s a hash of the URL and the domain name. This is useful for deduplication, and because some web pages have multiple RSS feeds on it.

Rather than create HTML output, I decided to make Markdown output, because the Obsidian editor is smoother than using a web browser. (An HTML version of the project would require creating index files, at the very least.)

I also wanted the program to be able to produce other formats in the future, like JSON files, so emitting Markdown seemed like a good first step.

The decision was to have files as input, and files as output, so this workflow could be part of a larger workflow.

At all times, I wanted the programs to run standalone, outside of Thaura Work. Thaura Work can run the program, and I have it do that, but I would like to just run the workflow without Thaura Work most of the time.

The decision was to run outside of Thaura, and save energy.

Other Decisions

I don’t really like the program’s output, and prefer a less chatty TTY, but Thaura Work uses the extensive messages as a debugging aid. So they remain.

I didn’t like a lot of the code it produced, at first, but have fought resisted “fixing” it. I assume the code produced is a reverse map back into the conceptual tokens deep in the model. I shouldn’t touch it too much.

I had it create a GUI program for the most common form of input – a single URL. I didn’t want to use Terminal to submit my URLs.

It created a great little one-line input dialog, and it shows the program output in the lower pane. That’s so snazzy!

I had it write a C program to create a double clickable icon that runs the GUI program.

Some Interesting Prompts

run the command with https://truthout.org observe the output and fix bugs

It just ran the program over and over, fixing bugs. Pretty amazing.

make sure that when run.py is called with --refresh, that it resets the state of all the good urls from processed to unprocessed

This created a way to re-run the good URLs, running a step in the workflow without running all the steps. The workflow is made up of steps, each one working a bit like a workflow.

create a naming convention for the files in the url and rssurl folders. use a hash(url) and domain in the filename. this can help speed up deduping urls.

This was really nice. It understands about putting the data in the file, and essential metadata in the filename, so it forms a “key”.

After stating this, it edited the code to use the convention all over. Unfortunately, it seems to have repeated code. If I were coding this, I’d have a library of functions to create standardized names. Oh well.

The code is only as correct as it has to be.

please clean up the project, removing deprecated programs

It is doing a much hated task!

(I shouldn’t have used “please”.)

Surprises and Thoughts

I had originally made the program to process a single URL at a time. Along the way, Thaura Work subverted me, and changed it, so processing the inbox loops over the whole thing.

I did not want that optimization, because it means I can’t interrupt the workflow, quit after the current “crank of the handle”, and resume it.

I’m assuming this optimization will be worse when this workflow becomes subsumed in a larger one.

Building the app as commands makes it easy for Thaura to run it and debug it.

However, to “tie it all together”, when I normally write programs like this by hand, I make libraries to standardize things like file naming, reading data files, and so forth.

I didn’t do that with Thaura, so it produced a lot of repetitive code, and broken code. However, it eventually fixed the bugs. It just never did it with little abstractions.

I should have used JSON or INI or whatever Thaura produced as the data format, and made a small library to create the filenames, load data records, write data records, enforce fields, etc. Then, I could see if Thaura could learn it and use it, and maybe save some tokens.

I’m not sure how much time I saved by coding this with an LLM. A lot of the conversations were exploratory.

The post Thaura Work: Vibe Coding an RSS Feed Aggregator first appeared on 🍙.

Repeat for the following topics: “Gaza War”, “Iran War”, “Gas Prices”, “Recession”, “Inflation”

Repeat for the following topics: Gaza War, Iran War, US China Relations, California Governors, Voting Rights Act, Inflation Crisis, Economic Pain, Rise in Racism, Rise in Misogyny, Arcadia Mayor Resigns, Anti-Chinese Sentiment, Asian Americans and Gentrification, Los Angeles Mayor’s Race, Housing Affordability, Climate Change, Pollution, AI and Jobs, AI and War, Trade Conflicts, Healthcare, Health Insurance, Supply Chain, Interest Rates, Energy and Power

(Note that the longer the list is, the more the LLM will hallucinate headlines and links. It also helps if the news source has an RSS feed. It seems to know how to use those, sometimes. Otherwise, I don’t know how it’s getting the news. I realize this makes the LLM sound like a shit version of an RSS feed aggregator.)

for the wordpress contact form 7 plugin, create a form with the fields first name, email, phone, zip, and a list of checkboxes for the following categories of stuff to give away: vintage, electronics, computer parts, scrap metal, office supplies, art supplies, boxes, clothes, housewares, books.

consider index_builder.py to be obsolete legacy within this new system. implementing new commands is acceptable.

(This helps to release Work from holding on to it’s goal of retaining backward compatibility.)

update then clean up the docs

(Telling Work to work on the docs seems to help. It also externalizes some of the internal state into a file, so it can be re-read in the future, or in the event of a crash.)

continue

(Work keeps a to do list and plans. It doesn’t always complete them. So “continue” will tell it to keep working on it.)

Warm up the context:

How does Thaura find dependencies between tasks in a task list?

Then, copy-paste a bunch of your recent chat messages about a project:

Extract all the listed tasks or to-dos in this chat:

Then, tell it to try its best ordering the tasks, and also ask for additional info as needed:

Please put these tasks in order. Ask if clarification is necessary. Keep refining the order until the list is in the correct order.

Tell it to examine a prior project, and specifically note the features I feel are useful to copy. These features took a long time to create.

Look at ../Reading Material Archive.thaura/ and study the documents in there (but ignore the numbered folders because they are the actual document archives). study about how the PDF files were classified as books, journal articles, pdf prints of web pages, etc.

After some time generating code, I ask it to consolidate repetitive code into libraries. (It saved several hundred lines of code.) I’m trying to use the DRY style of programming – bottom-up, where you first produce code, then consolidate.

are there opportunities to DRY out the code and put some functions into a library?

A vibe coded app was going really well, but it was really bugging me that the plugin extension system was obviously inefficient. So I started a new chat and did this:

go into version 2, and do a cursory review of the code, and explore the extension system, and suggest ways to make it more efficient.

It went wild and found 9 optimizations, some obvious, some not, and most were pretty sophisticated. It took a lot of time, and it had a huge back-and-forth with itself and lots of code edits to implement them all, undo some of them because they were mistakes, and so forth.

The post Thaura Prompt Collection first appeared on 🍙.