DEV Community: Gabriel Almeida

I Haunted My Terminal With a Local Ghost (Gemma 3, No Internet Needed)

Gabriel Almeida — Mon, 26 Oct 2026 23:30:44 +0000

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

What I Built

shell-ghost is a haunted terminal. After some of the commands you run, a ghost whispers one eerie line about what you just did:

$ rm -rf node_modules
  👻 Don't worry, it just wanted a little... tidier oblivion.

$ git push --force
  👻 Don't you dare rewrite my carefully crafted digital chaos.

$ sudo make me a sandwich
  👻 It wants fillings… and a very long, slow, digital chew.

By default it speaks on about 1 in 3 commands, so it stays a surprise instead of a nuisance.

Demo

Repo: https://github.com/GAlmeidaDev/shell-ghost

How It Works

Two tiny files, no dependencies beyond Python 3 and zsh:

haunt.zsh hooks into zsh with preexec (to remember the command) and precmd (to read its exit code). It rolls a die, and if the ghost is feeling chatty it calls the script.
ghost.py sends the command and exit code to a local model through Ollama's HTTP API and prints one dim purple line.

The whole prompt is a few lines: you are a ghost trapped inside a computer, reply with one short eerie whisper, spooky and a little funny. Temperature 0.9 and a 48-token cap keep it short and weird.

Try it:

ollama pull gemma3:4b
python3 ghost.py "rm -rf node_modules" --code 1
echo 'source /path/to/shell-ghost/haunt.zsh' >> ~/.zshrc

Set GHOST_ODDS=1 and it speaks after every command.

Why Open Source AI Matters Here

A terminal sees everything: your commands, paths, hostnames, sometimes secrets typed inline. Sending that to a hosted API for a joke would be a bad trade.

With an open-weight model running locally:

Nothing leaves your machine. The only network call is to localhost.
It works offline. Plane, train, or a dead Wi-Fi: the ghost still haunts you.
It can't break your shell. If Ollama isn't running, the call fails silently and the ghost simply stays quiet.
You pick the ghost. --model swaps in any model Ollama can run.

A 4B model is plenty for one spooky sentence, and that's the point: small, open models are good enough to make tools feel alive without a cloud dependency.

What I Learned

Small models follow "ONE line, max 18 words" surprisingly well, but splitlines()[0] is still a cheap safety net.
For shell tooling, failing silently is a feature. A decorative tool must never be able to hurt the thing it decorates.
Randomness (the 1-in-3 odds) matters more than model quality for the "haunted" feel.

hf26challenge

sloth-sorter: a lazy file tidier that runs Gemma locally

Gabriel Almeida — Tue, 20 Oct 2026 13:15:29 +0000

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

What I built

sloth-sorter 🦥 is a file tidier for people who keep putting off cleaning Downloads. Point it at a folder: a local open-weight model (Gemma 3 4B through Ollama) reads each file, picks a category folder, and gives it a clean kebab-case name. It's a dry run by default, so nothing moves until you pass --apply.

ollama pull gemma3:4b
python3 sloth.py ~/Downloads            # preview
python3 sloth.py ~/Downloads --apply    # move files

It's about 60 lines of stdlib-only Python — no pip install.

Demo

I made a messy folder with five files and ran it:

Untitled-3.txt   ->  notes/meeting-notes.txt
doc (1).txt      ->  contracts/service-agreement.txt
export.csv       ->  docs/export-csv.csv
final_final2.py  ->  code/fib.py
scan_0001.txt    ->  invoices/scan-2041.txt

The model got four of five clearly right. export.csv (a list of expenses) landed in docs instead of something better, and its name just repeats the extension. Small models are imperfect, which is exactly why the dry run exists.

The lazy payoff

Five files took about 12 seconds on a laptop, with zero decisions from me. Sorting them by hand means opening each one to remember what it is. The saving grows with the folder: you review a list instead of reading files.

Why open innovation matters here

Your Downloads folder holds invoices, contracts and personal notes. Sending those to a hosted API just to rename them would be a bad trade. With an open-weight model running through Ollama, file contents never leave the machine, it costs nothing per file, and I can swap the model with --model for a bigger or smaller one.

How it works

For each file it sends the name plus the first 600 characters (or just size/type for binaries) to Ollama with format: json, validates the folder against a fixed list, sanitizes the name, and avoids overwriting by appending a counter.

Code

GAlmeidaDev / sloth-sorter

What I'd do next

Read PDFs and images (a vision-capable Gemma), and add an undo log.

Built with: Gemma 3 (Best Use of Gemma), Ollama, Python.

Local Receipts: a receipt organizer for freelancers, powered by local Gemma 3

Gabriel Almeida — Tue, 13 Oct 2026 00:17:26 +0000

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

What I Built

Local Receipts is a receipt organizer for Brazilian freelancers and MEIs (micro-entrepreneurs). You give it the text or a photo of a receipt or invoice, and it returns the vendor, tax ID (CNPJ), date, total and expense category. At the end of the month you get a summary by category and a CSV that opens straight in Brazilian Excel.

The person who would pay for it is the freelancer who spends the last weekend of every month digging through receipts for their accountant. Those receipts hold client names, tax IDs and amounts, which is exactly what you don't want to upload to someone else's server.

Demo

Real output from my machine, with the model running locally:

curl -X POST localhost:3000/receipts -H 'content-type: application/json' \
  -d '{"text":"PADARIA PAO QUENTE LTDA\nCNPJ: 11.222.333/0001-81\nEmissao: 03/10/2026\nTOTAL R$ 21,50"}'

{
  "id": 1,
  "vendor": "PADARIA PAO QUENTE LTDA",
  "cnpj": "11222333000181",
  "cnpjValid": true,
  "issuedOn": "2026-10-03",
  "totalCents": 2150,
  "currency": "BRL",
  "category": "alimentacao",
  "needsReview": false
}

A month of receipts exports to a CSV with ; separators, decimal commas and a UTF-8 BOM, so it opens correctly in Excel without any import wizard:

data;fornecedor;cnpj;valor;moeda;categoria;revisar
2026-10-03;PADARIA PAO QUENTE LTDA;11222333000181;21,50;BRL;alimentacao;não
2026-10-08;Notion Labs Inc.;;10,00;USD;software_e_assinaturas;sim
2026-10-10;POSTO ESTRELA COMBUSTIVEIS;44555666000100;198,40;BRL;transporte;sim

The last two rows are flagged for review on purpose: the Notion invoice is in dollars, and the gas station's tax ID fails validation (I made it up for the test).

Code

GAlmeidaDev / local-receipt

🧾 Local Receipts

Organize os recibos do seu MEI ou freela sem mandar um centavo (nem um CNPJ) para a nuvem.

Você envia o texto ou a foto de um recibo ou nota fiscal. Um modelo open-weight rodando na sua máquina (Gemma 3 4B via Ollama) lê o documento e extrai fornecedor, CNPJ, data, valor e categoria. O código confere o CNPJ (dígitos verificadores) e marca para revisão tudo que não consegue confirmar. No fim do mês, você tem o resumo por categoria e um CSV que abre direto no Excel brasileiro.

Feito para o Hacktoberfest 2026 Open-Source AI Challenge, tema Side Hustle.

Por que não confiar só no modelo

Um modelo de 4B parâmetros lê bem, mas erra. Por isso o modelo só sugere e o código decide:

CNPJ: validado com os dígitos verificadores. Inválido ou ausente → needsReview.
Moeda: o valor nunca é convertido. Documento…

View on GitHub

How I Built It

The open-weight model. Gemma 3 4B, served by Ollama on my own machine. It reads both text and images, so one model handles pasted text and photos of receipts. Ollama's format field takes a JSON schema (generated from a zod schema), so the model has to answer in a fixed shape. The reply is validated with the same schema, and an invalid one becomes a clean 503 instead of garbage in the database.

The model suggests, the code decides. A 4B model reads well but is wrong sometimes, and it is bad news when it is wrong about money. So everything checkable is checked outside the model:

The CNPJ is validated with its two check digits. If it is missing or invalid, the receipt is flagged.
Amounts are stored as integer cents.
The same document is never entered twice (content hash).
If the date, tax ID or total can't be confirmed, the receipt gets needsReview: true, and the model is told to answer null rather than guess.

Two bugs my own tests found. Mocked tests passed, so I ran real receipts through Gemma and found two problems:

A gas station receipt came back as food (alimentacao). Fix: I added a short category guide to the prompt, and it now comes back as transporte.
A US$ 10.00 invoice was saved as R$ 10,00 with no warning. That is the kind of silent error that costs real money. Fix: the model now extracts the currency, the amount is never converted, and any non-BRL document goes to review and stays out of the BRL total.

Both are the kind of failure a happy-path demo never shows. The final suite has 9 tests with the model mocked, and the real model was run against the cases above.

Stack: Node, TypeScript, Fastify, zod, SQLite (better-sqlite3), Ollama, Gemma 3 4B.

Why Does Open Innovation Matter?

Privacy is the product. A receipt has a CNPJ, an amount and sometimes a client's name. With a local model, none of it leaves the laptop, and that is a feature I can honestly put on the box.
The unit economics work. Processing 10 or 1,000 receipts costs the same: zero marginal cost. There is no per-token bill that forces a subscription price up.
It works offline.
No lock-in. OLLAMA_MODEL swaps the model, and open weights mean a model could later be fine-tuned on Brazilian invoices, which a generic API handles unevenly.

I didn't compare against a closed API, so I won't claim it would extract worse. The point is where the data goes and what each document costs.

Limitations

My photo test used a clean image I generated myself. A crooked, shadowed phone photo will fail more often, and I haven't measured by how much.
No direct PDF support yet (convert to an image or send the text).
Categories are the model's suggestion, so review what comes flagged.
No login: it is designed as a single-user local tool.

What's Next

A tiny upload page, PDF support, and fine-tuning on Brazilian invoice formats.

Prize Categories

Best Use of Gemma: Gemma 3 4B runs locally through Ollama and does all the extraction, for both text and photos.

TouchGrass API: outdoor missions from local Gemma 3 and the weather

Gabriel Almeida — Tue, 06 Oct 2026 18:30:00 +0000

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

What I Built

TouchGrass API is a small backend that answers one question: "I have 20 free minutes. What should I do outside?"

You send it a city and the minutes you have. It looks up the current weather, hands that to a local open-weight model, and returns one short, concrete outdoor mission that fits both the sky and your schedule. Drizzle gets a "stand under an awning and listen to the rain" mission. A clear afternoon gets a walk with a destination. Do the mission, check in, and the API tracks your streak of consecutive days.

It is three endpoints on purpose, so the screen stays the shortest part of the experience: ask, read one paragraph, go outside.

POST /mission takes { city, minutes } and returns a mission.
POST /checkin marks a mission as done. It is idempotent.
GET /streak returns { current, longest, completedToday }.

It is built for anyone who wants a nudge off the screen without installing another app that wants their data. Because it is an API, it can sit behind a CLI, a shortcut, a widget or a bot.

Demo

This is a real response from my machine, with the model running locally:

curl -X POST localhost:3000/mission \
  -H 'content-type: application/json' \
  -d '{"city":"Curitiba","minutes":20}'

{
  "id": 1,
  "title": "Observação da Garoa",
  "description": "Saia e observe a garoa que cobre Curitiba. Concentre-se nos sons da chuva, nas gotas que escorrem pelas folhas e na sensação do ar úmido no rosto. [...]",
  "minutes": 20,
  "weather": {
    "city": "Curitiba",
    "temperatureC": 14.4,
    "precipitationMm": 0.2,
    "windKmh": 10.8,
    "isDay": true,
    "condition": "garoa"
  }
}

Curitiba was drizzling at 14 °C when I called it, and the model proposed a rain-listening mission instead of a jog. That is the point: the weather changes the mission.

Code

GAlmeidaDev / TouchGrass-API

🌱 TouchGrass API

Fecha o notebook. Abre a porta. Vai pegar sol.

API em Node/TypeScript que olha o clima da sua cidade e pede a um modelo de IA open-weight rodando na sua máquina uma missão curta ao ar livre, do tamanho do tempo que você tem. Feita para o desafio Touch Grass do Hacktoberfest 2026 Open-Source AI Challenge (DEV).

Como funciona

POST /mission {city, minutes}
   │
   ├─► Open-Meteo (geocoding + clima atual, sem chave de API)
   └─► Gemma 3 4B via Ollama (local) ─► missão em JSON validado
         │
         └─► SQLite (histórico de missões)

Endpoint	Status	O que faz
`POST /mission`	✅	Gera uma missão para a cidade e o tempo livre informados
`POST /checkin`	✅	Marca a missão como cumprida (`{"missionId": 1}`); idempotente
`GET /streak`	✅	Dias seguidos com missões cumpridas
`GET /health`	✅	Health check

Como rodar

Requisitos: Node 20+ e Ollama.

ollama pull

…

View on GitHub

How I Built It

The open-weight model. Missions come from Gemma 3 4B served by Ollama, running on my own machine. It is about 3.3 GB and fast enough on a regular laptop.

Structured output instead of prompt-and-pray. A 4B model is happy to ramble. I pass a JSON schema (generated from a zod schema) in Ollama's format field, so the model has to answer { "title", "description" }. The reply is then parsed with the same zod schema, and anything invalid becomes a clean 503 rather than garbage in the database. The system prompt asks for pt-BR, a mission that fits the time including the walk back, no equipment, and a safe alternative when there is rain, a storm, extreme cold or darkness.

Weather without an API key. Open-Meteo handles geocoding and current conditions, so there is nothing to sign up for. I map the WMO weather code to a readable condition, and the model sees temperature, feels-like, rain, wind and day or night.

Streaks. Missions live in SQLite (better-sqlite3). Check-ins store the local day, and the streak is computed from distinct completed days. It stays alive if your last completed day was yesterday, so you have until the end of today to keep it, and it resets after a skipped day while preserving your longest run.

Testable by design. The weather provider, the mission generator and the clock are injected into the Fastify app. The 12 tests run with no network and no Ollama, and the clock injection let me test consecutive days and a month rollover without waiting.

Stack: Node, TypeScript, Fastify, zod, SQLite, Ollama, Gemma 3 4B, Open-Meteo.

Why Does Open Innovation Matter?

Privacy. The model runs on your machine. Where you live and how often you go outside is not sent to an AI provider. The only outbound request is the weather lookup, which carries a city name.
Offline-capable. Inference needs no internet. Only the forecast does.
Zero cost. No API key, quota or per-token bill, so a habit app can call the model every day for free.
Swappable. Open weights mean one environment variable (OLLAMA_MODEL) swaps the model. A closed API can change or retire a model under you.

I haven't tried the closed-API version of this, so I won't claim it is worse. For a tool about personal routine, keeping the data local was the deciding factor.

Testing It

I ran the full flow against live weather and the local model. In Curitiba (heavy drizzle, 14 °C, 15 minutes) it proposed a rain-watching mission. In Lisbon at night (20 °C, 45 minutes) it switched to a night walk by the river instead of a daytime route, so the weather and the time of day do change the output. A check-in moved the streak to 1, and repeating the same check-in changed nothing. An unknown city returned a clean 404.

The honest limitation: with a 4B model the missions lean toward "observe and reflect", and the minutes barely change their scope. The next thing I'd try is a richer prompt (varied mission types per duration) or a bigger Gemma through the same OLLAMA_MODEL switch.

What's Next

This is the backend only. Next I want a tiny client (CLI or phone shortcut) and per-user time zones. Right now days follow the server's time zone, which fits the local, single-user setup.

Prize Categories

Best Use of Gemma: Gemma 3 4B runs locally through Ollama and generates every mission.