catchup: a lazy morning brief for group chats, on a laptop with no internet

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

catchup reads a WhatsApp chat export and prints a short brief: the lines worth reading (times, amounts, open questions, plans) with who said them, plus an optional one-line gist from a small local model. it is for the group chat you skipped last night and don't want to scroll.

the lazy part: you export once, run one command, and read ten lines instead of two hundred messages.

nothing leaves the machine. the model is optional: without it you still get the digest.

this project was built fully autonomously by an AI coding agent on my behalf. i did not write the code myself.

Update (Oct 20): v2 and v3

the first version let Gemma 3 1B write the whole brief. when i read those briefs against the chats, they were often wrong about who did what. so v2 changed the split: the facts are copied verbatim from the chat by plain rules, and the model only writes one sentence about what the chat is about. that sentence is dropped if it names anyone, has a digit, is long, or fails the old name and number check.

v3 (later the same day) adds problem words like "stuck" or "out of" to the rules and raises the cap from 10 to 12 lines. it also fixes a parser bug that a fresh test set found: any message containing the word "left" ("i left them at home") was thrown away as a system line.

Demo

https://maybesomeone-arc18.github.io/catchup/demo/

the page runs the rules digest in your browser (paste an export, no upload). the Gemma gist is precomputed from the CLI and shown as it came out, with the recall score for each chat.

Code

https://github.com/MaybeSomeone-arc18/catchup

How I Built It

1. a parser reads the export, drops system lines, joins wrapped lines, flags media.
2. rules pick up to 12 lines: times, amounts, question marks, plan words, problem words, your name. they print verbatim with the sender.
3. optional: Gemma 3 1B (Q4_K_M, llama.cpp) writes one gist sentence at temperature 0. the checker rejects it if it names a person, has a digit, or is not one short sentence.
4. a chat with nothing worth reading prints "Nothing needs you."

stack: Python, llama-cpp-python 0.3.36. 26 unit tests. the old model-only brief is still available with --v1.

What I measured

metric: gold-string recall. for each chat i wrote down, before running, the strings a reader must not miss (a time, an amount, an open question). the score is how many show up in the output. it is a proxy: it does not grade whether a sentence is right. 2-core, 2 GB RAM sandbox, one run per cell.

set	v1 model-only	v2	v3
dev, 8 chats, 39 gold (tuned on)	15/39 = 38.5%	37/39 = 94.9%	38/39 = 97.4%
set C, 4 chats, 24 gold (misses seen, so used)	10/24 = 41.7%	22/24 = 91.7%	24/24 = 100%
set D, 4 fresh chats, 20 gold, before the parser fix	6/20 = 30%	18/20 = 90%	18/20 = 90%
set D after the parser fix (now used)	6/20	19/20	19/20

the only fair row is set D before the parser fix: i wrote those chats and their gold strings before running any version, and it is 4 chats. there v2 and v3 tie. the v3 gains on dev and C come from rules i wrote after seeing those misses, so i do not count them as evidence. what v3 really bought is the parser bug fix. v1 to v2 is the big jump: 30% to 90% on fresh chats, and about 7 s to 4 s per brief.

what is still missing: tickets (goa-trip, over the line cap) and compressor ("i think the compressor is going": no time, question or problem word).

the digest is not always short. on an 18 or 19 message chat it prints 12 lines. on 9 to 13 message chats it prints 5 to 10. longer chats are untested.

the original version of this post said 3 of 4 briefs passed the checker and that two of the three passing ones had wrong claims (for example "Ma called Didi" when Rohan did). that was a different run on the first 4 chats. Gemma is not fully repeatable between runs, so v1 moves a little each time.

the gists are vague one-liners and can be slightly off (on the family chat it blurs the cake and the plumber). the verbatim lines are the part to trust.

Why Does Open Innovation Matter?

• group chats are private. with an open-weight model the chat stays on your own machine, with no server and no account.
• it costs nothing to run, so a lazy tool does not turn into a subscription.
• i could see and control the whole pipeline, so when the model was the weak part i could shrink its job and keep the rest. with a closed API i could not enforce "only facts from the source" like this.

where open was worse: a 1B model is weak at attribution. a bigger open model would likely do better, but i did not test one.

Limits

• 16 tiny synthetic chats (3 to 19 messages), all written by me. no real private chats, no field use.
• gold-string recall rewards copying lines, and the digest is built to copy them. it does not tell you whether the brief is a nicer read.
• long chats would hit the 10-line cap, and the gist only sees the first 40 messages. not tested.
• only the d/m/yy, h:mm am - name: text export shape is parsed.
• no comparison with a larger or closed model.
• one run per number, not an average.