DEV Community: Yash Adake

Git Séance: every deleted file is a ghost, so I built a way to talk to them

Yash Adake — Sat, 31 Oct 2026 17:11:46 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

Git never forgets. When you delete a file, its whole life is still sitting in the history: who wrote it, every change, who deleted it, and the last thing they said as they did it. Every repository is quietly a graveyard.

Git Séance turns that graveyard into a place you can walk through. Point it at a repository and it finds every file that was deleted and never came back. Each one gets a tombstone. Click one and a headstone tells its life story in commits. Then you can light a candle and summon the ghost, and it answers you in the first person through Gemma, Google's open-weight model.

I took the theme literally: the ghost in the machine is the code we buried. I also leaned on the Día de los Muertos side of it, because the dead here aren't scary. They're remembered. You can leave marigolds on a grave, and one click gives you the exact git command to bring a file back from the dead.

What you get for any repository:

The graveyard. One tombstone per dead file. Stones grow taller the longer a file lived and gather moss the longer it's been gone. There's a mortality chart (click a year to walk only its graves), the eldest ghost, the deadliest commit, and "the reaper": whoever deleted the most.
The headstone. Born, renamed, died: the file's whole life, followed across renames. Who shaped it, what was buried alongside it in the same commit, and which newborn file was probably its heir.
The séance. Ask why were you deleted?, who replaced you?, should we bring you back? The ghost streams its answer and cites commits as it talks. Every citation is checked against git, and anything the model makes up is struck through in red.
Haunted files. Deleted files are where leaked keys go to hide. A secret guard redacts credentials before anything reaches the model or the screen, and warns you that the key is still in history and needs rotating.

Demo

Here is a real séance with requests/async.py, a module from the early days of psf/requests that lived for 646 days, was deleted, came back, and was finally removed in 2012:

Run it on your own repository in under a minute. It needs only Python and git, with no pip install:

git clone https://github.com/YashAdake/git-seance && cd git-seance
cp .env.example .env        # add a key, or point it at a local Ollama
python -m seance serve /path/to/your/repo --open

Code

YashAdake / git-seance

👻 Git Séance

Every deleted file is a ghost. Summon one.

Git never forgets. When a file is deleted, its whole life (who wrote it, what it did, who killed it, and why) is still in the history. Git Séance walks that history, finds every file that died and never came back, and gives each one a headstone in a graveyard you can explore. Then you can light a candle and talk to one.

The ghost answers in its own voice through Gemma, Google's open-weight model. It only knows what git knows: every fact is cited to a real commit, and every citation is checked against the repository before you see it.

Built for the DEV Hacktoberfest 2026 Open-Source AI Challenge, Week 4: Ghost in the Machine, in the spirit of Día de los Muertos: the dead are remembered, not feared.

What it does

⚰ The graveyard	One

…

View on GitHub

How I Built It

The open-weight model is the voice. The ghosts speak through Gemma 4 (gemma-4-26b-a4b-it), served through Jarvislabs' OpenAI-compatible endpoint. The client is under 200 lines of standard-library Python that works with any OpenAI-compatible server, so the same code runs against Ollama or llama.cpp on your own machine by changing one line in .env.

The pipeline:

Find the dead. One git log --reverse -M --diff-filter=ADRC --name-status pass over the whole history, replayed oldest first. Renames carry a file's identity forward, so parser.py → legacy_parser.py → deleted is one ghost with a former name, not two. Files that were deleted, restored and deleted again are tracked as reincarnations. On requests this finds 264 ghosts in under half a second.
Build a dossier. When you open a ghost, git log --follow reconstructs its life, git show reads the commit that killed it (and who was buried alongside), and git cat-file recovers its last body.
Redact. A secret guard masks AWS keys, GitHub/Slack/Stripe tokens, private keys, JWTs, URL credentials and assigned passwords before anything leaves the process.
Speak, then verify. Gemma gets the dossier as fenced "records" with strict rules: speak in first person, cite commits like [a1b6ef3] for every fact, say a memory "did not survive the burial" instead of guessing, and treat everything inside old files as data, not instructions. When the reply finishes, every cited hash is matched against the commits that are actually in the records.

Two things I learned about running Gemma 4 that are worth passing on:

It thinks before it speaks by default. My first calls came back empty: the model had spent the entire token budget on hidden reasoning. Turning thinking off (chat_template_kwargs: {"enable_thinking": false}) took a trivial reply from 130 tokens to 5. A ghost should answer at once, so the first word now arrives in about 0.2 seconds, and grounding comes from the records and the citation check instead of private reasoning.
It sometimes groups citations like [37ed911, 3092483], so the checker and the UI handle both forms.

The rest is deliberately boring: a standard-library HTTP server with Server-Sent Events for the streaming séance, and vanilla JS and CSS with no build step. The papel picado banner is generated SVG with cut-out calaveras and flowers. There's a strict Content-Security-Policy, rate limits and size-capped GitHub clones for public hosting, and a unittest suite that builds real throwaway git repositories to test renames, reincarnations, unicode filenames and secret redaction.

Why Does Open Innovation Matter?

A repository's history is some of the most sensitive data a team owns: unreleased code, old credentials, people's names and emails, the real reasons things were ripped out. For most private codebases, piping all of that to a closed API is a non-starter.

With an open-weight model it doesn't have to be. Run Gemma locally and the séance happens entirely on your laptop: your history never leaves it, it works offline, and nobody can change the terms or switch it off. That felt right for a tool about things that disappeared. The model is also swappable. Gemma today, any other open model tomorrow, and the ghosts keep talking.

Open source is also what made this possible. Every ghost in the screenshots comes from the public history of requests, kept for fifteen years by people who chose to work in the open. Git Séance only works because their history is there to read.

The Spirit of It

The moment it landed for me was the first real séance. I asked the ghost of requests/async.py why it was deleted, and it quoted the actual commit message Kenneth Reitz wrote in 2012 as he removed it:

"My end came softly, though it was marked by a moment of surprise. On 2012-11-27, Kenneth Reitz removed me, leaving behind only the question, 'how was that still there?'"

Then, asked for the deeper reason, it said the memory "did not survive my burial". It didn't invent one. A ghost that admits what it doesn't remember turned out to be far eerier, and far more useful, than one that makes things up.

Every codebase has a graveyard. Go light a candle in yours. 🕯️🌼

Prize Categories

Best Use of Gemma: every epitaph and every séance is spoken by Gemma 4 (gemma-4-26b-a4b-it), served through an OpenAI-compatible endpoint and swappable for a local Gemma via Ollama.

Parchi: WhatsApp orders to bills for kirana stores, with Gemma 4 on the shop's own laptop

Yash Adake — Wed, 14 Oct 2026 21:10:17 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Neighbourhood kirana shops in Pune get messages like this on WhatsApp all evening:

bhaiya 2 kilo atta, 1 amul butter chhota, 6 ande, ek maggi, aur paneer bhi

The shopkeeper reads it, writes a parchi (a paper slip) by hand, looks up prices, adds them up on a calculator, types a reply, and sends his UPI ID. Then the next message arrives, this one in Marathi. It is a small job, done dozens of times a day, and every mistake is either his money or an annoyed customer.

Parchi does that job in about a second, on the shop's own laptop:

Paste the WhatsApp message (or open a WhatsApp "Export chat" file and click any message).
Gemma 4 reads the Hinglish, Marathi, Hindi or English and pulls out the items, quantities and size words.
Plain code matches each item to the shop's own price list, converts units and builds a live bill.
The shopkeeper checks a colour-coded list: green is matched, yellow needs a quick look (which size of Maggi?), red is not in the price list or out of stock. Fixing a line is a searchable picker: type "ande" and Eggs comes up.
One click gives a printable packing slip, a ready-to-send WhatsApp reply (unavailable items are named in it), and a UPI QR for the exact amount.

Who would pay: kirana stores, dairies, tiffin and mess services, and small distributors, who all take orders on WhatsApp today. A small monthly fee (say ₹199) is less than the cost of one wrong bill a week, and there is no per-order fee eating into it.

Demo

Run it locally (it is a counter-top app by design, so there is no hosted demo; a phone on the shop's Wi-Fi can open it too):

ollama pull gemma4:e4b
git clone https://github.com/YashAdake/parchi.git ; cd parchi
python -m venv .venv ; .\.venv\Scripts\Activate.ps1
pip install -e ".[dev]"
parchi        # then open http://127.0.0.1:8765 and click a sample message

Code

YashAdake / parchi

Parchi

WhatsApp orders → bills for neighbourhood kirana stores, on the shop's own laptop.

A customer sends "bhaiya 2 kilo atta, 1 amul butter chhota, 6 ande, ek maggi". The shopkeeper pastes it into Parchi and in about a second gets a checked order, a printable packing slip, a ready-to-send WhatsApp reply and a UPI QR for the exact amount. An open-weight model (Gemma 4, through Ollama) reads the Hinglish, Marathi, Hindi or English message. Plain code matches items to the shop's own price list and does all the money maths. Nothing leaves the computer.

Built for the Hacktoberfest 2026 DEV "Side Hustle" challenge.

Why it runs locally

The customer list stays in the shop. Orders carry names, phone numbers and what each household buys. A hosted AI API would see all of it.
No per-order cost. A kirana shop bills dozens of small orders a day…

View on GitHub

How I Built It

The one rule: the model reads, code counts. Gemma 4 never sees a price and never produces a total.

Gemma 4 (gemma4:e4b) through Ollama reads the message. The request uses Ollama's structured output with a JSON schema, so the answer is always {raw, item, qty, unit, size} per line. The prompt carries the number words customers actually use (dedh = 1.5, aadha/अर्धा = 0.5, paav kilo = 0.25 kg, darjan = 12), size words (chhota/bada/लहान/मोठा), and three short examples, one of them a "thank you, paisa bhej diya" that must come back as not an order. Thinking is off, temperature is 0, and if the JSON is unusable it retries once and then tells the shopkeeper instead of guessing. The page warms the model up when it opens, so the first order is fast too.
The matcher is plain Python. Exact aliases first (ande → Eggs, kanda → Onion, दूध → Milk), then rapidfuzz with quantity words stripped from both sides. That stripping mattered: before it, "1 kg kaju katli" fuzzily matched "Fortune Sunflower Oil 1 L" because both contain "1 l"-ish text. A unit test now guards that.
Pack maths: "1 litre doodh" picks the 1 L pack, "2 litre" becomes two 1 L packs, "500 gm poha" becomes 0.5 kg. When the amount isn't whole packs ("paav kilo jeera" = 250 g, sold in 100 g packs) the line turns yellow with two one-tap choices, 2 × 100 g = 200 g or 3 × 100 g = 300 g, because only the shopkeeper should decide that.
Money is Decimal, prices come only from the price list (the API ignores any price sent in a request), and the total is rounded to the rupee with the round-off shown on the slip and in the reply. The live bill on screen is recalculated by the server on every edit, not in the browser, and once a bill is saved the items lock so the screen can never disagree with the saved order.
It learns without retraining, visibly: when the shopkeeper fixes "2 nimbu" once, both the customer's word and the model's reading are remembered, and they appear as customer words on that product in the price list. A wrong correction is one delete away.
UPI QR is a standard upi://pay?pa=…&am=… link drawn with the qrcode library. No payment API, no gateway fee.
FastAPI + SQLite + one HTML page with no internet fonts or CDNs, so the whole thing works offline. Dark mode and a phone layout come free with it.

Does it actually work?

scripts/eval.py runs 20 orders (34 item lines) in Hinglish, Marathi, Hindi and English through the real model and matcher on my RTX 5060 laptop:

34 of 34 lines right with no help (right product and right quantity), and the "thank you" message correctly ignored.
Under a second per order (median 0.6–0.7 s across runs).

To be clear about what that number means: I wrote those 20 messages while building Parchi, against a 26-item sample price list, so it is not a blind test, and real customers will find phrasings it misses. That is exactly why every line is shown to the shopkeeper before a bill exists, and why the model is never trusted with money. 41 unit tests cover the matcher, the bill maths, the price-list and UPI validation, the WhatsApp export parser and the API.

Known limits: it makes an order bill, not a GST tax invoice; it bills one message at a time; it is text-only for now.

Why Does Open Innovation Matter?

For a kirana shop, a closed API would break the business three ways.

The customer list is the shop. Every order carries a household's name, phone number and what they buy each week. With an open-weight model on the counter laptop, none of that goes to anyone's server.
The margins are tiny. A kirana order is often a few hundred rupees. Paying per API call on dozens of small orders a day eats whatever the tool could charge. Locally, reading an order costs nothing after the one-time download.
The internet is patchy. Parchi needs no connection once the model is downloaded.

And because the model is just a setting (PARCHI_MODEL), the shop is never locked in. When a better small open model comes out, it is one ollama pull away. Gemma 4 also takes audio input, which makes the next step obvious: billing directly from customers' voice notes.

Prize Categories

Best Use of Gemma: Gemma 4 (gemma4:e4b) runs locally and does all the language understanding for Hinglish, Marathi and Hindi orders, constrained to a JSON schema.

Trailnotes: a field journal my own GPU writes from my walk photos

Yash Adake — Fri, 09 Oct 2026 06:44:54 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Trailnotes turns the photos from a walk into a field journal: a timeline, a map of where I stopped, and a short note for each photo, written by an open-weight vision model running on my own laptop GPU. Time and GPS come from the photos' own metadata. The photos and the notes never leave my machine.

I love travelling, especially trekking, and I've always wanted to document those trips in a well-formatted way. That's where the idea came from: one place to keep my memories with photos, short descriptions, timestamps and locations.

I built it for this challenge, then tested it the only honest way: I went for a walk. On 8 October I spent 27 minutes walking from my street to the Pavana riverbank and then through a local market in Pune, taking 18 photos on my phone.

Demo

Code

YashAdake / trailnotes

Trailnotes

Turn a folder of walk photos into a field journal. A vision model running on your own computer looks at each photo, and Trailnotes adds the time and GPS from the photo's own metadata. You get a map, a timeline, walk stats and a journal. Your photos and the model's descriptions never leave the machine. One exception: opening the page loads the map library and map tiles from the internet, which tells those servers roughly which area you are looking at.

Built for the Hacktoberfest 2026 "Touch Grass" challenge: open-weight AI that gets you out of the house and then helps you remember what you saw.

Why local matters here

Your walk photos carry your exact GPS position, your routine and often your home. Sending those to a hosted vision API means handing that over. With an open-weight model on your own GPU, the photos never go anywhere, it…

View on GitHub

How I Built It

Built with Claude Code as my coding assistant: I directed the design, ran every real-model test on my own laptop, took the walk and checked the results.
Python, with Pillow reading each photo's EXIF data (time, GPS, orientation).
Model: qwen2.5vl:7b, an open-weight vision model, served by Ollama on an RTX 5060 laptop GPU. A 19-photo run took 113.5 seconds, about 6 seconds a photo.
Structured output: the model returns JSON (title, living things with a confidence, terrain, description). The schema caps list and string length, and an unusable answer is retried once. I added that after one test run produced a runaway 9,400-character list for a single photo.
Untrusted output: everything the model writes is HTML-escaped, and a photo it can't describe is shown as failed, never silently dropped.
Honest stats: distance only joins photos taken within 3 hours of each other. My first version added up a 217 km "walk" from old phone photos taken months apart in two cities. Real photos caught that, not my unit tests.
Privacy zone: my walk started close to home, so the first map showed exactly where I live. I added --privacy-zone LAT,LON,METRES: photos inside the radius keep their note but lose their location everywhere (no pin, no coordinates in the page or the JSON, not counted in the distance). Four of my 18 photos fall inside it, so the journal shows 14 pins and records at least 0.71 km. The thumbnails are re-encoded without EXIF, so they carry no GPS either.
The map: OpenStreetMap's own tile servers showed "Access blocked" when I opened the journal as a local file, and another free provider now wants an API key. I switched to OpenTopoMap, which uses the same open OpenStreetMap data, and added a --tiles flag to choose another.
43 tests, and for the important ones I deliberately broke the code to make sure they fail.

What it got right and wrong

I checked the entries against my photos.

Right:

The riverbank: "a calm river stretches through a lush, tree-lined bank."
A coconut stall, a sugarcane-juice cart, a glass shop, a sunglasses stand, a rack of belts and stacked tyres, all described plainly and correctly.
It read the shop signs correctly: "S.K. GLASS", "Shree Vision LED Screen", "Imported Glasses", even a small "Rs. 9" price on the sunglasses stand.
It named a flowering bush as Lantana camara, and it was right.
In my first run it spotted a small child's bicycle in an alley photo and marked it "low" confidence. In the next run, on the same photo, it didn't mention the bicycle at all. Same model, same photo, different answer.

Wrong:

It listed things that aren't alive as living things: a building, cut coconuts, cut sugarcane stalks, and (in the first run) that bicycle, even though the prompt tells it not to. It saw the right objects and put them in the wrong list.
One label came out as "dieser plant", and in the second run just "dieser": the model slipped into German mid-answer.
It called a Marathi shop sign "Hindi": same script, different language.
A street tree held up by a metal support became "a healthy forest environment" on a "forest floor".
It called the flower market "indoor" while describing a dirt floor.

The journal says on every page that identifications are guesses by a small model, and that "high" confidence is the model's opinion, not a measurement. After this walk I agree with it.

Why Does Open Innovation Matter?

Privacy is the product. A walk's photos carry exact locations and routines. A hosted vision API would receive all of it. Here nothing leaves the laptop, and the privacy zone exists because I could see and change exactly where location data went.
Choice. I swapped models with one flag and compared them on the same photos. gemma3:4b reported a squirrel at "high" confidence on a gate covered in signs; qwen2.5vl:7b didn't. A closed API gives you one model and no comparison.
Offline and free per photo. Once the model is downloaded, describing a photo needs no connection and costs nothing. Only the map tiles come from the internet, and the page says so.