DEV Community: Harsh Bhadu

Haunted Git Blame: When Your Codebase Talks Back

Harsh Bhadu — Thu, 29 Oct 2026 13:04:37 +0000

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

What I Built

I built Haunted Git Blame, a local-first Git history seance that turns the recent history of a software repository into a spooky, traceable case file.

The idea began with a simple question: if a codebase could remember everything that happened inside it, what kind of ghost story would it tell?

A repository already contains the ingredients of a haunting. There are abandoned branches, unfinished features, repeated fixes, sudden bursts of activity, long silences, and commit messages written by people who may have moved on to other projects. Haunted Git Blame reads those traces and gives them an atmosphere without pretending that the software can literally know a developer's intentions.

The user pastes the path to a local Git repository. The app reads up to 18 recent commits and collects bounded metadata:

Commit hashes
Short commit hashes
Author names
Commit dates
Commit subjects
Files changed
Insertions and deletions

That evidence becomes a visual report. The interface shows a recovered transmission, a mood, cited commit hashes, and a chronological commit timeline. The generated narrative is always tied back to real commits so the experience stays playful without becoming completely ungrounded.

The project interprets Ghost in the Machine in two ways:

The repository is treated like a haunted archive. Its commits are the footprints left behind by people and decisions that are no longer visible in the present code.
The AI itself is deliberately kept local and replaceable. The “ghost” does not need to live on a remote server. It can run on the builder's own machine, even when the internet is unavailable.

The visual design follows that idea. Haunted Git Blame looks like a damaged local archive rather than a conventional dashboard: dark paper, ember-red signals, scanlines, faint noise, warning stamps, old terminal typography, and a timeline that makes every commit feel like a recovered mark.

Demo

Local demo: Run the project locally and open:

http://localhost:3000

The project is intentionally designed as a local application because privacy is part of the demo. To run it:

npm install
npm run build
npm start

Then paste the path to a local Git repository with at least one commit.

For an Ollama-backed demo, configure an installed local model before starting the server:

$env:OLLAMA_MODEL = "tinyllama:latest"
$env:OLLAMA_URL = "http://127.0.0.1:11434/api/generate"
npm start

The application has also been tested in fallback mode with Ollama unavailable or configured with a model that is not installed. In that case, the interface remains functional and produces a built-in local archive narration instead of an empty result.

Code

Repository: [https://github.com/HarshDev-07/Git-Haunted-Blame]

The project is structured as a small Node.js and TypeScript application with a plain browser client:

src/
  ai.ts       Ollama adapter, response normalization, and offline archive voices
  git.ts      Safe Git inspection and commit parsing
  server.ts   Local HTTP server and API route
  types.ts    Shared response types
public/
  index.html  Accessible application structure
  app.css     Offline-safe haunted archive visual system
  app.js      Browser interaction and report rendering
README.md     Setup, privacy, troubleshooting, and challenge documentation

The main implementation is intentionally readable. There is no large framework hiding the important behavior and no hosted service required to understand the full request path.

The project uses:

Node.js
TypeScript
Native Node HTTP APIs
Native fetch for the Ollama request
The installed Git command-line tool for repository inspection
Ollama-compatible local inference
Vanilla HTML, CSS, and JavaScript for the interface

The server invokes Git with argument arrays rather than interpolating a user-provided path into a shell command. The project does not clone, fetch, push, commit, or modify the repository.

The repository response is also privacy-conscious. The server uses the absolute path locally to inspect the requested repository, but the browser-facing API returns only the repository folder name. The complete local path is not returned to the client.

The Ollama endpoint is restricted to local loopback addresses such as localhost, 127.0.0.1, and ::1. Remote endpoints and embedded credentials are rejected before commit metadata is sent.

How I Built It

Haunted Git Blame is built around local Ollama inference. Ollama provides a local HTTP endpoint that can run open-weight models on the user's own machine. The exact model is configurable, so the app is not tied to one provider or one model family.

The default configuration expects:

http://127.0.0.1:11434/api/generate

The user can choose an installed model through the OLLAMA_MODEL environment variable. During development, I verified the application with an installed tinyllama:latest model. A different local model can be used without changing the browser interface or Git adapter.

The flow is deliberately bounded:

The user selects a local repository by entering its path.
The server validates the directory and checks that Git can inspect it.
Git returns a maximum of 18 recent commits.
The server extracts metadata and short statistics rather than reading the entire source tree.
That structured commit evidence is placed into a carefully scoped prompt.
Ollama is asked to return JSON containing a title, message, mood, and evidence hashes.
The app validates the response and keeps only evidence that matches real commits.
The browser renders the result as a recovered transmission and timeline.

The prompt instructs the model to stay within the supplied evidence. It asks for exact commit hashes and tells the model not to invent people, files, or events. The application still treats model output as interpretation rather than fact, which is why the cited hashes remain visible in the interface.

The AI adapter also handles the reality of local inference. A local model may be unavailable, may not be installed, may take too long, or may return malformed JSON. These conditions should not destroy the whole application. Instead, the adapter falls back to the built-in archive cabinet.

The offline cabinet contains several deterministic voices chosen from repository signals:

The first and final breath for a repository with one commit.
The silent maintainer for a repository whose latest commit is more than a year old.
The repeated footsteps when one author accounts for a long sequence of commits.
The unfinished room when the recent history contains substantial code churn.
The repository remembers for a quieter mixed history.

This means the project has two useful modes:

Ollama mode: a local open-weight model creates the atmospheric interpretation.
Local archive mode: built-in text produces an offline, deterministic experience without AI inference.

The second mode is not just a backup for a broken demo. It is an important part of the product design. A local-first tool should remain useful when the model is missing, the laptop is offline, or the user does not have enough hardware to run a larger model.

The browser interface uses no external fonts, images, stylesheets, or JavaScript services. The haunted visual language is made with local CSS: scanlines, noise, archival borders, ember colors, signal bars, subtle flicker, and a responsive timeline. This keeps the presentation available when the internet is switched off as well.

Why Does Open Innovation Matter?

Open innovation matters because the material Haunted Git Blame examines can be sensitive by default.

A Git history may reveal:

Internal project names
Unreleased product ideas
Security-related fixes
Customer or organization terminology
Names of contributors
Work that was never intended to be public
The timing and structure of a team's development process

A closed hosted AI API would make it easy to send that information away simply to produce a fun narrative. That would be the wrong tradeoff for this project. The spooky effect is not worth giving up control of a private codebase.

Running an open-weight model locally makes a different design possible. The repository stays on the user's machine. The model endpoint is inspectable. The prompt is visible. The model can be changed. The user can run the app with the network disconnected. There is no account requirement, API key, per-request charge, or dependency on a remote provider remaining available.

Open innovation also changes the creative process. Because the model is replaceable, Haunted Git Blame can evolve in several directions:

A smaller model can be selected for an older laptop.
A stronger model can be selected for richer writing.
A model can be fine-tuned or prompted for a particular historical tone.
The prompt can be changed to emulate an archivist, detective, séance host, or systems historian.
The Git evidence boundary can be audited and changed by the project owner.
The app can remain useful even if no model is installed.

A closed API might have made the first prototype quicker, but it would have hidden the most important question: where does the repository history go? With local inference, the privacy decision is part of the architecture instead of a footnote in a privacy policy.

The open approach also improves durability. A hosted service can change pricing, remove a model, change its terms, or disappear. An open local setup gives the project a better chance of remaining understandable and runnable. The model is one component, not the owner of the application.

There is a second kind of open innovation in the project: the fallback behavior. The application does not pretend that AI is the only source of value. The Git history itself is useful. The deterministic archive voices make that visible and keep the experience available without a model. This makes the project more honest and more resilient.

The Spirit of It

The part that stayed with me was the idea that a repository can be full of evidence but empty of explanation.

A commit named file-upload may be the beginning of a product, the last surviving fragment of an experiment, or simply the only door left open in an abandoned project. Git records what changed, when it changed, and who made the change. It does not record what the developer hoped would happen next.

That gap is where the haunting lives.

Haunted Git Blame does not claim to resurrect the people behind a repository. It gives the traces a voice while keeping the original evidence visible. The report can be dramatic, but the hashes remain real. The story is allowed to be eerie because the timeline keeps it accountable.

The offline cabinet is part of that spirit too. If the model cannot answer, the repository does not become silent. A one-commit project can still receive The first and final breath. A long-quiet project can still receive The silent maintainer. Those messages are small, but they make the absence itself part of the story.

The result is a tool that treats old code with a little ceremony. Not every abandoned repository needs to be revived as a product. Sometimes it only needs someone to notice that it was there.

Prize Categories

Primary category: Github-Copilot

Slowly: Remember Your Renewals Before Your Wallet Does

Harsh Bhadu — Sun, 25 Oct 2026 06:16:23 +0000

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

What I Built

Everyday subscriptions create a small but persistent mental task: remembering when a free trial ends, when a plan renews, and when to cancel autopay before an unwanted charge. Slowly is a local-first subscription tracker that keeps those details in one calm, private place.

It lets people add, edit, archive, search, and filter subscriptions while showing estimated monthly spending, active subscription count, and upcoming renewals. It also supports JSON backup and import, so the data remains portable and under the user's control.

Slowly includes an optional natural-language entry workflow. A user can describe a subscription, receive a structured draft from a local AI model, review and edit the result, and then save it. AI is helpful, but it is never required for the core tracker.

Demo

hosted demo- [slowly_url]
https://harshdev-07.github.io/slowly--Hacktober/
The project can be also run locally with:

py -m http.server 4173

Then open http://localhost:4173.

Code

The complete source code is available here:

Slowly GitHub repository

How I Built It

Slowly is built with vanilla HTML, CSS, and JavaScript ES modules. There is no npm dependency or build step. Subscription records are stored locally in the browser with IndexedDB, and a service worker plus web app manifest provide an offline-capable progressive web app experience.

The optional AI workflow connects to a local Ollama-compatible /api/generate endpoint. The default model is llama3.2:3b, but the endpoint and model can be changed in the app settings. The model turns a natural-language description into structured JSON. Slowly parses and validates that response locally, then presents it as an editable draft before anything is saved.

This design keeps the normal workflow usable without an account, analytics, cloud database, paid API, or exposed API key.

Why Does Open Innovation Matter?

Open innovation made it possible to build around local, open-weight AI instead of making a personal finance utility dependent on a closed hosted API. Users can choose the model that runs on their own machine, inspect how the response is handled, and keep subscription data in their browser.

The project is also intentionally easy to understand and contribute to. A contributor can open a small set of plain HTML, CSS, and JavaScript files without learning a framework build system first. That lowers the cost of improving a tool whose goal is to lower everyday cognitive load.

The Lazy Payoff

Slowly turns a recurring mental calculation into a quick dashboard check. Instead of keeping several renewal dates in memory or searching through emails when a free trial is ending, the user can see what is renewing soon, what each plan costs, and which payment details belong to it.

The payoff is small each day, but it compounds: fewer reminders to remember, fewer tabs to search, and fewer surprise renewal charges.

Prize Categories

GitHub Copilot

BookFlip Tutor: A Local AI Coach for Smarter Book Reselling

Harsh Bhadu — Sun, 18 Oct 2026 13:26:10 +0000

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

What I Built

BookFlip Tutor is a local-first learning tool for students, freelancers, and first-time book resellers who want to know whether a used book is worth buying before they spend money.

A user can choose a seeded example or paste a marketplace listing. BookFlip Tutor then helps turn the listing into a resale decision by showing:

Buy price and inbound shipping
Expected sale price and marketplace fees
Estimated profit and return on investment
Risk flags for missing ISBN, unclear edition, shipping cost, and thin margins
A plain-language explanation of what to verify next

The product is designed for a small, specific side hustle: helping a beginner avoid bad textbook purchases and learn the reasoning behind a good sourcing decision. A paid version could charge for saved sourcing history, guided textbook niches, batch listing review, or a private local workflow for tutors and small resellers.

The financial calculation is deterministic. The AI is not trusted to invent prices or perform arithmetic.

Demo

Open index.html from the repository, or serve the project folder with any static file server.

Code

Repository: github.com/HarshDev-07/DevProj-2

The main implementation is intentionally small and dependency-free:

index.html contains the product workflow.
styles.css contains the responsive interface.
app.js contains seeded listings, Ollama integration, validation, deterministic calculations, risk flags, quiz behavior, and local saved history.
README.md documents setup, architecture, privacy, and limitations.
LICENSE provides the MIT license.

How I Built It

BookFlip Tutor is a browser app with an optional local AI path through Ollama.

The user can configure a lightweight local model such as qwen2.5:3b or another compatible open-weight model. The app sends the pasted listing to Ollama's local /api/generate endpoint with:

stream: false for a simple browser workflow
format: "json" for structured output
Low temperature for more consistent extraction
A prompt that explicitly says not to guess missing numbers

The expected response contains structured fields such as:

{
  "title": "Campbell Biology",
  "edition": "12th edition",
  "condition": "Very good",
  "buyPrice": 38,
  "shipping": 6,
  "expectedSalePrice": 96,
  "marketplaceFee": 14.4,
  "missing": []
}

The app validates numeric fields before using them, exposes the extracted values for manual correction, and keeps the existing calculator available if Ollama is not installed or running.

The architecture is:

flowchart LR
  A[Marketplace listing text] --> B[Ollama open-weight model]
  B --> C[Validated facts and uncertainty]
  C --> D[Manual review and correction]
  D --> E[Deterministic profit calculator]
  E --> F[Estimate, risk flags, and lesson]
  F --> G[Local browser history]

To run Ollama locally:

ollama pull qwen2.5:3b
ollama serve

Then open the app, click Check connection, paste a listing, and click Extract with Ollama.

Why Does Open Innovation Matter?

The local model is what makes this product practical as a small side hustle rather than another usage-metered API wrapper.

Privacy: Book listings, sourcing notes, and saved opportunities can stay on the user's laptop instead of being sent to a third-party inference service.

Cost: A lightweight open-weight model can run without a per-request bill. That matters when a beginner is checking low-cost books where a hosted API charge could consume the entire margin.

Choice: Users can replace the model with another Ollama-compatible model, choose a smaller model for an older laptop, or later tune the workflow for textbooks, exam-prep books, or a regional marketplace.

Transparency: The user can see and correct extracted fields before they affect the estimate. The app keeps financial rules in ordinary application code, so the model cannot silently change the profit calculation.

Offline potential: Once the model is downloaded, the extraction workflow can work without an internet connection. The current app does not require a hosted backend for its core seeded examples, calculations, lessons, or saved history.

AI Use Disclosure

I used AI assistance during development for implementation support, code drafting, interface iteration, and documentation. The project also uses Ollama as an optional runtime for an open-weight model. The product keeps model output reviewable and does not treat AI-generated extraction as a guaranteed fact.

Prize Categories

Best Use of GitHub Copilot

BookFlip Tutor was built with GitHub Copilot assistance for implementation, debugging, interface iteration, and documentation. Copilot helped turn the product concept into a working browser demo while the project remains open-source and understandable as a small codebase.

Categories Not Claimed

I am not claiming the Render, TabPFN, Tinker, Arduino, DigitalOcean, Gemma, Backboard, ElevenLabs, Entire, Mastra, MongoDB Atlas, Sentry, SerpApi, .tech, Temporal, or Tiger Data categories because the current implementation does not use those technologies.

Escape the Keyboard: LocalWhisper Pro Helps You Actually "Touch Grass"

Harsh Bhadu — Thu, 08 Oct 2026 13:30:45 +0000

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

What I Built

LocalWhisper Pro is an open-source, offline-first voice interface designed to minimize screen time. Instead of spending hours hunched over a keyboard typing emails, documentation, or field notes at 40 WPM, users dictate naturally at 150+ WPM. Local AI instantly cleans, restructures, and auto-types the text directly at the cursor—enabling users to wrap up screen work fast and get outdoors.

How it gets people off the screen and into the world:

Makes the screen the shortest interaction: Speech is up to 4x faster than typing. By handling filler-word scrubbing, formatting, and summarization automatically, users spend a fraction of the time staring at word processors and code editors.
100% Offline Trail & Field Ready: Because both transcription and refinement run entirely on-device, you can take your laptop outside—onto the porch, into a garden, or down a hiking trail without cell signal—to dictate field logs, nature observations, and ideas without internet dependencies.
No Clipboard or Cloud Distractions: It uses low-level hardware stroke injection (SendInput / pynput) rather than pasting through clipboard history, keeping workflows seamless and distraction-free.

Demo

Direct Download: Download the standalone Windows executable (LocalWhisper_Pro_v3.1_Windows.zip) directly from our GitHub Releases page—no Python runtime required.

Code

Repository: [https://github.com/Harsh-Dev07/Local-WhisperFlow]
License: Open Source (MIT)

How I Built It

LocalWhisper Pro is architected entirely around open-source AI models and local runtime frameworks:

Local Speech Recognition (faster-whisper / CTranslate2):
Audio input is captured locally using sounddevice and processed through faster-whisper, a reimplementation of OpenAI's Whisper model running on the CTranslate2 inference engine. This delivers up to 4x faster-than-real-time transcription on consumer CPUs/GPUs without external network calls.
Local Intelligence & Text Refinement (Ollama + llama3.1:8b):
Raw transcription often suffers from stutters, repetitions, and unstructured ramblings. LocalWhisper integrates directly with local Ollama instances. Using open-weight models like llama3.1:8b, it cleans transcripts across multiple modes:
- Smart Dictation: Removes filler words while maintaining personal voice.
- Field & Bullet Summary: Distills stream-of-consciousness rambling into structured, actionable checklists.
- Code & Tech: Synthesizes voice logs into camelCase, snake_case, and terminal commands.
- Hinglish/Hindi Processing: Accurately interprets code-switched multi-language dictation.
System Overlay & Direct Keystroke Emulation:
The interface is a lightweight, non-stealing glassmorphic HUD built in Python (Tkinter). Refined text bypasses the operating system's clipboard (Win+V) and is typed directly into active windows via hardware-level event hooks (pynput), ensuring zero data retention outside the user's encrypted local history.

Why Does Open Innovation Matter?

Open innovation was not an afterthought for this build—it was a prerequisite:

True Offline Portability: Closed-source voice-to-text platforms (like Google Speech-to-Text or OpenAI Whisper API) fail the moment you walk into a park, mountain trail, or remote campsite without Wi-Fi or cellular service. Open-weight models (faster-whisper + Llama 3.1) run autonomously on consumer laptops off the grid.
Complete Sensory Privacy: Voice notes recorded outdoors or in private moments often include personal thoughts, journal entries, and sensitive project ideas. Open-source local models guarantee that no spoken audio or transcribed text ever hits corporate telemetry servers or third-party training pipelines.
Zero Ongoing Cost: Proprietary APIs charge per audio minute and per token, which discourages long, ambient voice captures. Open-weight inference costs nothing to run, whether you record a two-second note or an hour-long outdoor brainstorm.
Model Modularity: Users have the freedom to swap out the refiner engine for smaller models (e.g., phi3, gemma2:2b) on low-power devices, or larger parameter models on dedicated hardware.

Prize Categories

Hacktoberfest Open-Source AI Challenge: Week 1 (Touch Grass)