DEV Community: Mahasvan Mohan

Hacktoberfest Week 4 - Excavate deleted files

Mahasvan Mohan — Sat, 31 Oct 2026 04:29:06 +0000

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

What I Built

Every long-lived repository has a graveyard hidden inside .git/objects: thousands of lines of deleted functions, retired modules, and hard-won edge-case fixes that were swept away during a "clean v2 rewrite"—often taking the institutional memory of why they existed with them.

git-seance is a zero-dependency, single-file Python CLI that bridges both halves of the Ghost in the Machine theme:

The Spooky Git Séance (Halloween): Excavates deleted files and major code removals from Git history (git log --diff-filter=D and historical diffs) and channels them through a local open-weight LLM (llama3.2, qwen2.5-coder, or deepseek-r1 via Ollama / llama.cpp). The deleted code speaks from beyond the grave in first person—grounded in its actual deleted source code, commit epitaph, creation history, and deletion date—so you can ask it why it was written and what production bug is about to happen now that it's gone.
The Code Ofrenda (--ofrenda, Día de los Muertos): Renders a marigold-and-candlelight terminal Ofrenda de Código that honors departed modules and the original contributors who crafted them, complete with an AI-generated remembrance blessing.

Demo

Run git-seance immediately on any machine with Python 3 and Git (includes a built-in --haunt-demo mode that conjures a temporary haunted repository so you can test it in one command):

# 1. Build a Día de los Muertos Code Ofrenda
python3 git_seance.py --haunt-demo --ofrenda

# 2. Hold an interactive séance with Spirit #2 (legacy_rate_shield.py)
python3 git_seance.py --haunt-demo --spirit 2

# 3. Ask a deleted module a single question from the command line
python3 git_seance.py --haunt-demo --spirit 2 --ask "Why do our workers crash every midnight after you were deleted?"

Sample Terminal Output (`--haunt-demo --ofrenda`)

  ✿ 🕯️  ═══════════════════════════════════════════════════════════ 🕯️  ✿
         OFRENDA DE CÓDIGO — HONORING THE CODE THAT CAME BEFORE
  ✿ 🕯️  ═══════════════════════════════════════════════════════════ 🕯️  ✿

  ✿ Marigolds laid for 2 departed modules (20 lines of ancestral logic)
  🕯️ Ancestral builders honored: Elena Vance, Mateo Cruz

  ┌─ 🕯️  Spirit #1: zombie_reaper.py (commit 71d038d)
  │  Crafted by : Mateo Cruz  |  Departed: 2025-11-02 (by Chad Dev)
  │  Epitaph    : "Remove zombie_reaper.py - cloud auto-heals right?" (10 lines lost)
  │  Relic      : def reap_orphan_sockets(active_pids: list[int]) -> int:
  └──────────────────────────────────────────────────────────────
  ┌─ 🕯️  Spirit #2: legacy_rate_shield.py (commit d5654bc)
  │  Crafted by : Elena Vance  |  Departed: 2024-10-31 (by Chad Dev)
  │  Epitaph    : "Nuke legacy_rate_shield.py in v2 cleanup (YOLO)" (10 lines lost)
  │  Relic      : def verify_midnight_token(token: str, clock_skew_ms: int = 300) -> b
  └──────────────────────────────────────────────────────────────

Code

The entire tool is open source and available here:

GitHub Repo: Mahasvan/hacktoberfest-submission

It is implemented as a single, dependency-free script (git_seance.py) using only the Python standard library (subprocess, urllib.request, json, argparse) + Git + local open-weight inference.

How I Built It

Git Graveyard Excavator: Uses subprocess pipelines (git log --diff-filter=D, git log --format=%an <commit>~1 -- <path>, and git show) to recover the exact deleted lines, the commit epitaph that killed the code, the person who deleted it, and the original author who wrote it.
Open-Weight Local Inference Core: Connects directly to Ollama (http://localhost:11434/api/chat) or any local OpenAI-compatible server (llama.cpp, vLLM, LM Studio via /v1/chat/completions) using standard-library HTTP calls.
Grounded Spirit Persona: Each spirit's system prompt is dynamically assembled from its resurrected diff, author lineage, and commit metadata so the open-weight model answers technical archaeology questions in character without hallucinating outside the diff. Inside an interactive séance, typing resurrect prints the raw deleted source code back to the terminal.

Why Does Open Innovation Matter?

Private Codebases & Zero Data Leakage: The most haunted repositories are legacy enterprise or proprietary codebases where years of commits contain sensitive business logic, internal architecture, or accidentally deleted security guards. Running an open-weight model locally (qwen2.5-coder or llama3.2 on a laptop with no internet) means you can interrogate your entire .git history without ever sending private diffs to a closed cloud API.
Zero Marginal Cost for Deep Git Archaeology: Scanning historical diffs across dozens of deleted modules would burn through cloud API tokens rapidly. Local inference on consumer hardware costs $0.00 per séance.
Model Freedom & Permanence: Just as Git preserves history locally forever, open-weight models ensure you can swap between small fast models (llama3.2:3b) or code-specialized models (qwen2.5-coder:7b) offline, without worrying about a vendor deprecating an endpoint.

The Spirit of It

Software engineering often treats old code as embarrassing technical debt to be deleted and forgotten. Framing deleted code as an Ofrenda de Código shifts that perspective: the ugly 15-line workaround written four years ago by an engineer who has since left the company was usually protecting the system from a very real production scar. Honoring those past builders—and giving their deleted code a voice to explain why it stood watch—turns git blame into gratitude.

Spending Tracker - Hacktoberfest Week 3

Mahasvan Mohan — Wed, 21 Oct 2026 17:11:28 +0000

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

What I Built

I built a Smart Spending Tracker that completely eliminates the dreaded chore of manual budgeting. Let’s face it: manually entering expenses into spreadsheets—picking categories, inputting dates, and typing out exact amounts—is tedious. It’s exactly the kind of task we procrastinate on.

To channel my inner sloth, I created a tracker that rewards laziness. Instead of navigating menus, you just brain-dump your expenses in plain text (e.g., "Spent 15 bucks on a burrito for lunch and 40 on gas"). The underlying open-source AI instantly parses your messy input, extracts the amount, assigns the correct category, dates it, and logs it for you. You get to be incredibly lazy, but your finances stay perfectly organized.

Demo

(Insert a link to your live demo, or drop in a YouTube/Loom video link showing how easy it is to log an expense!)

Code

Mahasvan / SpendingTracker

Spending Tracker

A personal macOS spending tracker with an AI chatbot that reads and modifies your finances using natural language.

Features

Dashboard - income/expense summary, spending trends, top categories, budget progress, payment method distribution, recent transactions, largest expense, and month-over-month comparisons
Transactions — full CRUD with list view, inline rows, and editor sheet.
Advanced Search — filter by text, date range, type, amount, and category/payment-method chips
Budget Tracking - per-category monthly budgets
AI Chatbot - Currently Supports Ollama and Apple Intelligence. Add, update, delete transactions; search data; generate summaries - all in natural language (e.g., "Add ₹250 lunch paid by UPI"). Supports visual inputs, using LLM Vision capabilities, or using the macOS Vision API
Category & Payment Methods - customize names, colors, icons; archive unused items
Backup & Restore - JSON backup with merge or replace modes

Tech Stack

Swift 6 · SwiftUI · SwiftData · Swift Charts · swift-markdown-ui…

View on GitHub

How I Built It

My project is built around open-weight models and local inference.

Instead of writing complex Regex to parse human text, I integrated an open-source AI model [Note: e.g., Llama 3.2 / Mistral running locally via Ollama / Transformers.js] as the core engine. When the user submits a messy string of text, the prompt is passed to the local model which is instructed to extract the item_name, amount, and category, returning it purely as structured JSON.

The frontend/backend [Note: mention your framework, e.g., Next.js, Python/Flask, etc.] captures this JSON and instantly logs it to the database. The AI does all the heavy lifting of categorizing and structuring the data, so the user doesn't have to.

Why Does Open Innovation Matter?

When it comes to personal finance, privacy is everything. Open innovation is the only reason a project like this can exist securely.

Because this project uses open-weight models and local inference, it can run entirely offline on a laptop. Users don't have to send their daily habits, sensitive financial data, or location history to a closed-source, third-party API server (like OpenAI) that they don't control. Their financial data stays strictly on their own machine. Furthermore, because it relies on open-source AI, there are zero subscription fees to keep the automated tracking running. It’s private, free, and completely under the user's control.

My Agent Session

(If you used DevRelay to help build this, embed your session here! Otherwise, you can safely delete this section.)

The Lazy Payoff

I usually put off budgeting until the end of the month, at which point I'm forced to sift through dozens of bank statements and receipts—a chore that usually takes over an hour.

By building this tracker, I've turned a dreaded monthly chore into a 5-second brain dump whenever I buy something. It saves me hours of tedious spreadsheet management every month. More importantly, because it requires almost zero friction or mental energy, I actually stick to tracking my money now. I let the AI do the work so I can get back to relaxing.

Prize Categories

WasmEdge / LlamaEdge (Leave this if you used WasmEdge/LlamaEdge)
Neon (Leave this if you used Neon for your database)
Comet (Leave this if you used Comet to track your prompts)
Pinata (Leave this if you used Pinata)

W2 Dev Challenge - MUNHelper

Mahasvan Mohan — Thu, 15 Oct 2026 02:47:03 +0000

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

What I Built

MUNHelper is a specialized preparation assistant built for Model United Nations (MUN) delegates, specifically tailored for committees under the Economic and Social Council (ECOSOC).

Model UN delegates spend dozens of hours combing through dense, historical UN resolutions, past reports, and complex policy documents to find precise clauses, legal precedents, and actionable wording for their position papers and draft resolutions. MUNHelper solves this information-overload problem by running a Retrieval-Augmented Generation (RAG) pipeline across comprehensive ECOSOC resolutions, combined with an open-weight LLM layer to answer delegate queries instantly with exact contextual citations.

Who would pay for it? Competitive high school and university MUN delegates, as well as MUN coaching academies and school clubs, who are willing to pay for a tool that cuts research time in half and gives them a competitive edge during conferences.

Demo

Mahasvan / MunHelper

Fully offline Model United Nations Research Helper

MunHelper

Context-based UN Resolution lookup.
Searches through every existing ECOSOC resolution and shows relevant data and extracts.

Features

OpenAPI-compatible API using FastAPI
Website using Streamlit
Instant ECOSOC Resolution lookup with semantic search
Ability to update documents with latest resolutions
Integration with Ollama for inference from resolution extracts
Docker Containerization
Auto Update (coming soon)

Installation with Docker

Install Docker Desktop and make sure Docker Compose is present.
- If you want to use your GPU, follow Ollama's instructions.
Start the Docker Engine
- Windows/macOS - Open the app.
- Linux instructions
Navigate to the project directory
- ```
cd MunHelper
```
Start the containers in detached mode using docker-compose
- ```
 docker-compose -f docker-compose.yml up -d
```
API is served at http://localhost:5000/docs.
Frontend is served at http://localhost:3000.

Usage

Before using anything, update the ChromaDB database
- Visit the API Documentation at http://localhost:5000/docs.
- Run the /manage/update-chromadb endpoint.
- If using the Frontend
  - Hold on, I'm working on something.
- Otherwise…

View on GitHub

Code

You can explore the complete codebase and setup instructions directly on GitHub:

git clone https://github.com/mahasvan/munhelper
cd munhelper

How I Built It

MUNHelper is built entirely around open-source AI tooling to ensure precision, privacy, and low operational overhead:

Open-Weight Models: Utilizes local open-weight instruction-tuned models for text generation and summarization without depending on proprietary cloud endpoints.
Open-Source Orchestration & RAG: Built using open-source frameworks for document parsing, text chunking, and vector embedding generation (such as FAISS/Chroma for local vector storage and LangChain/LlamaIndex components).
Local Inference: The pipeline runs locally via lightweight runtime wrappers, allowing delegates to execute complex searches and context retrieval right on their laptops.

Why Does Open Innovation Matter?

Open innovation was non-negotiable for building MUNHelper for several key reasons:

Offline Conference Access: MUN conference venues notoriously have terrible Wi-Fi or restricted networks. Because MUNHelper runs locally with open-weight models, delegates can use it right up until committee session starts, even with zero internet connectivity.
Zero Per-Token API Costs: Commercial APIs charge per token, making a consumer-facing SaaS tool for students economically unviable. Running open-weight models locally keeps operating costs at zero, allowing for sustainable pricing models.
Privacy and Strategy Security: Delegates often input draft strategy notes and custom policy arguments alongside official documents. Keeping data processing local ensures that proprietary team strategies never leak onto third-party servers controlled by major tech companies.

Feedback

I tested MUNHelper with friends in a local college MUN team

What they said: They used it to cross-reference past resolutions on sustainable economic development and noted that it saved them hours of manual skimming through PDF archives. They especially liked that it worked offline during a mock committee session at a school where cell service was blocked.
Would they pay? They confirmed they would gladly pay a small one-time fee or seasonal subscription during conference season (September to January) to have access to a fast, reliable, offline policy research assistant.
What they asked for next: Exporting generated clause comparisons directly into a formatted Word or Google Doc template for draft resolutions.

Prize Categories

Open-Source AI Challenge Week 2: Side Hustle

Hacktoberfest Week 1 - Anti-Router

Mahasvan Mohan — Thu, 08 Oct 2026 05:53:15 +0000

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

What I Built

touch-grass is the Anti-Router: an offline-first wanderlust agent that plans exploratory pedestrian dérives — scavenger-hunt walks optimized for discovery, not speed.

Instead of telling you "turn left in 100 feet," it generates navigational riddles: "Face north. Somewhere north-west of here waits a fountain — follow the quietest path you can find, and let me know when you arrive." You have to actually look at the world — buildings, trees, water, art — to orient yourself. The phone stays in your pocket.

It's for anyone who walks the same three blocks every day and wants their own neighborhood to feel foreign again.

Demo

$ uv run touch-grass derive "Carmel-by-the-Sea, California" --minutes 45
Dérive: 2 waypoints, ~2.70 mi (budget 2.25 mi).
  - a tree @ (36.54186, -121.92063)
  - a tree @ (36.54569, -121.92933)

$ uv run touch-grass track   # feed "lat,lon" GPS fixes on stdin
You found a tree. Face north. Somewhere north-west of here waits a tree —
turn toward the north-west, follow the quietest path you can find...

On macOS, track also speaks each riddle aloud via say. A fully offline touch-grass demo simulates the whole loop — graph, routing, geofences, riddles — on a synthetic city.

Code

Mahasvan / touch-grass

touch-grass — the Anti-Router

Offline-first wanderlust agent: plans exploratory pedestrian dérives (scavenger-hunt walks) from cached OpenStreetMap data, then narrates navigational riddles instead of turn-by-turn directions.

Setup

uv sync                    # core deps (osmnx only — stays light)

For LLM riddles, run Ollama separately and set TOUCH_GRASS_MODEL (e.g. qwen3:4b). The daemon holds the weights; this package only talks HTTP to localhost — no heavy deps, no model in RAM.

Usage

uv run touch-grass demo                       # offline sim, synthetic city
uv run touch-grass derive "Portland, Oregon" --minutes 45

derive downloads the walk graph + POIs once, caches them under ~/.cache/touch-grass/, then works fully offline.

How it works

Module	Role
`spatial.py`	Cached OSMnx walk graph + POI tag extraction; radius from time budget
`router.py`	Anti-cost routing: penalizes arterials, rewards footways/alleys + jitter
`persona.py`	Turns bearings/POIs into riddles; template by default, GGUF LLM via `TOUCH_GRASS_MODEL`
`state.py`	Geofenced waypoint state machine —

…

View on GitHub

spatial.py — caches a pedestrian-only OSMnx walk graph + POI tags (historic=*, natural=*, leisure=park...) locally before you go offline
router.py — the Anti-Router: Dijkstra where arterials cost up to 50× and footways/alleys are discounted, plus seeded jitter so no two dérives repeat
persona.py — turns bearings and POI metadata into riddles via local Ollama (stdlib urllib, zero SDK), with a template fallback when no model is running
state.py — a 15 m geofence state machine: the LLM only wakes when you physically arrive

How I Built It

Everything runs at the edge:

Open-weight LLM: any Ollama-pulled model (e.g. qwen3:4b) served by a local Ollama daemon — TOUCH_GRASS_MODEL selects it, keep_alive: 5m drops weights between waypoints to save battery
Open data: OpenStreetMap via OSMnx — network_type="walk" graphs cached as GraphML, POIs pickled; after one fetch the app never touches the network
No agent framework: LangGraph/Smolagents were in the spec, but a 4-module pipeline didn't need them — plain functions won

Built with uv, testable headless (uv run pytest — no network, no model required).

Why Does Open Innovation Matter?

The entire premise — data sovereignty for where your feet go — only works because the stack is open. Google Maps can't power an app whose selling point is that no one logs your route. OSM gave me the graph, open-weight models gave me the voice, and Ollama gave me inference that works in airplane mode. A closed API would have made this project self-defeating: the agent's value is that it knows where you walked and tells no one.

My Agent Session

Built with Devin (SWE-2). Notable: the agent hit two real bugs on first live run — geopandas demanding pyarrow for a parquet cache (fixed by switching to stdlib pickle), and ox.nearest_nodes requiring scikit-learn on unprojected graphs (replaced with a 3-line equirectangular scan). Both fixes made the dependency tree lighter — staying honest to "offline-first" meant fewer deps, not more.

Prize Categories

Best use of open-weight models / local inference
Best offline-first / privacy-preserving project

DEV Community: Mahasvan Mohan

Hacktoberfest Week 4 - Excavate deleted files

What I Built

Demo

Sample Terminal Output (--haunt-demo --ofrenda)

Code

How I Built It

Why Does Open Innovation Matter?

The Spirit of It

Spending Tracker - Hacktoberfest Week 3

What I Built

Demo

Code

Mahasvan / SpendingTracker

Spending Tracker

Spending Tracker

Features

Tech Stack

How I Built It

Why Does Open Innovation Matter?

My Agent Session

The Lazy Payoff

Prize Categories

W2 Dev Challenge - MUNHelper

What I Built

Demo

Mahasvan / MunHelper

Fully offline Model United Nations Research Helper

MunHelper

Features

Installation with Docker

Usage

Code

How I Built It

Why Does Open Innovation Matter?

Feedback

Prize Categories

Hacktoberfest Week 1 - Anti-Router

What I Built

Demo

Code

Mahasvan / touch-grass

touch-grass — the Anti-Router

Setup

Usage

How it works

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

Sample Terminal Output (`--haunt-demo --ofrenda`)