DEV Community: Misbah Bagwan

Command Casperr: a tiny hand-drawn ghost that haunts your PowerShell terminal 👻

Misbah Bagwan — Sun, 01 Nov 2026 00:05:56 +0000

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

What I Built

I built Command Casper, a tiny hand-drawn ghost that floats on your screen and haunts your PowerShell terminal.

You type a command but don't press Enter. You press Alt+G. Casper looks at what you typed and turns green, yellow or red:

🟢 Green: it only reads things.
🟡 Yellow: it changes something, but you can usually undo it (installs, copies, a git commit).
🔴 Red: it destroys something or is hard to undo (deletes, overwrites, --force, download-and-run).

This is how casperr reacts when you ask it to evaluate a command !

Click the ghost and a speech bubble opens with a plain-English explanation, plus real facts about your actual folder: "this folder has 7 files, all edited today."

The theme gave me a perfect starting point. One of the example ideas on the challenge page was a haunted terminal that "possesses your shell." I wanted a friendly haunting, though. Casper isn't there to scare you. He's the ghost that says "hold up, human bean, think this through" right before you wipe a folder.

I'm fairly new to all of this, so I kept two rules:

It never blocks Enter and never runs your command. It only looks.
The AI never decides the colour. More on that below, because it's the most important design choice in the project.

Fun detail: the ghost is original pixel art i took from a template and enhanced myself (the rosy cheeks , the pink bow and ofcourse the signs !)

Demo

Below is the video where you will catch casperr shaking cause of a delete command !

Summon him and release him like this:

. D:\ghost\ghost.ps1
casperr summon     # "Casperr has been summoned!"
casperr release    # "Casperr has returned to the ghost realm!"

When summoned, he drops in from above and settles. When released, he does the same thing in reverse and fades away. Green bobs slowly, yellow a bit quicker, and red is frantic, because red should feel a little panicky.

Code

bagwanmisbah / CommandCasper-Ghost-in-the-Machine

👻 Command Casperr

A tiny hand-drawn ghost that haunts your PowerShell and warns you before you press Enter.

Type a command (don't press Enter), press Alt+G, and Casperr turns green, yellow or red. Click him for a plain-English explanation plus real facts about your folder.

Built for the Hacktoberfest Open-Source AI Challenge, Week 4: Ghost in the Machine.

🟢 Green	🟡 Yellow	🔴 Red
Only reads things	Changes something, usually recoverable (installs, copies, `git commit`)	Destroys or is hard to undo (deletes, overwrites, `--force`, download-and-run)

The one rule that matters

The rules decide the colour. The AI never does.

The colour comes from a plain, editable rules.json and a small deterministic engine (aliases, && chains where the worst command wins, quotes, > vs >>, -WhatIf making a command green, unknown commands default to yellow). The AI (Gemma 4, an open-weight model) is told…

View on GitHub

How I Built It

The model: Gemma 4 26B (gemma-4-26b-a4b-it), an open-weight model, served through Google AI Studio's free tier. No credit card, no cost.

The most important decision: rules pick the colour, the AI only explains.

My first instinct was "let the model judge the command." But a model that can be talked into a different answer is a bad safety guard. So the colour comes from a plain, editable rules.json and a small rule engine: aliases, && chains (the worst command in the chain wins), quotes, > vs >>, and -WhatIf making a command green. Anything unknown defaults to yellow. It's deterministic: same input, same colour, every time.

I tested the engine on 114 commands (37 green, 33 yellow, 44 red) and all pass. The tests also run automatically on every push with GitHub Actions.

The AI arrives afterwards. The bubble opens instantly with template text, then Gemma's explanation fades in a moment later from a background thread. The prompt tells it the verdict is final:

"The verdict is RED and it is final. Never contradict it, never change it. Use ONLY the facts given below."

It only receives the command, the verdict with its reasons, and counts or sizes ("7 files, 18.6 KB"). Never file contents.

If there's no key, no internet, or the API errors out, the bubble just shows the template text. The tool never breaks.

Other bits:
Windows PowerShell 5.1 with one PSReadLine key binding, a small tkinter window, and a plain UDP message to 127.0.0.1 between the two.
The hook lives in the current terminal session only, with no $PROFILE edits and nothing installed system-wide.
The AI part is pure Python standard library, so there's nothing to pip install. Everything lives in one folder.

What the model says

Same prompt, the rules choose the colour, Gemma 4 26B writes the explanation:

Command	Rules said	Gemma 4 26B
`pip install requests`	🟡	"This command installs Python packages by downloading code from the internet. Because it downloads new files to your system, it is marked as YELLOW."
`Copy-Item .\rules.json .\rules.bak`	🟡	"This command copies the file rules.json, which is 18.6 KB and was edited today, to a new backup file. This action is marked YELLOW because it copies files or folders."
`Remove-Item .\art -Recurse -Force`	🔴	"This command will delete the folder named .\art and everything inside it. This folder contains 7 files that were edited today. This action is permanent and cannot be undone."
`iwr https://example.com/setup.ps1` piped into `iex` (download and run)	🔴	"This command downloads a script from the internet and runs it immediately. You cannot see what the code will do before it executes on your computer. This is dangerous because it can perform unexpected actions without your permission."

Why Does Open Innovation Matter?

Swapping models is one line. The model name lives in a .env setting. Comparing two Gemma sizes took one flag. The code also speaks the common Open ai style request format, so pointing it at another provider or a local server should be a config change.
It cost nothing. The whole project runs on a free tier.
No lock-in for the important part. The thing that keeps you safe is a JSON file you can read, edit and argue with. The model is a replaceable explainer. If a provider changes its rules, Casper falls back to templates instead of dying.

The Spirit of It ( Thoughtfully following the Theme )

Casper is meant to be a gentle kind of spooky. I drew it pixel by pixel, gave it rosy cheeks and a bow and wrote for it lines like "Spooky. Are you sure about this?" and "Watch out, mortal!" The goal was a ghost that makes the scary moment of pressing Enter feel a bit less lonely, and maybe makes you pause for one second before the red command.

The lines live in a plain personality.json, so you can rename it and swap "mortal" for anything you like.

Built by
Misbah · Dev: @misbah_bagwan

Prize Categories

Best Use of Gemma: Gemma 4 26B writes every explanation, through Google AI Studio.
Best Use of GitHub Copilot: I used GitHub Copilot in VS Code while building (the repo includes my Copilot instructions file), and the rule tests run automatically on every push with GitHub Actions.

Built with help from AI assistants (Claude and GitHub Copilot). The design decisions, the art, the rules and the testing are mine.

Music credits: nastelbom-halloween-halloween-music-621496 by Nastelbom, from Pixabay

Ghost Template credits :PixilArt

Tab Debt: Make Room for What Matters

Misbah Bagwan — Sun, 25 Oct 2026 21:01:17 +0000

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

What I Built
Tab Debt is an AI-assisted Chrome extension that helps clean up inactive and duplicate browser tabs without forcing users to decide manually what to keep.

Many of us keep dozens of Chrome tabs open “just in case.” Over time, those tabs consume browser resources, occupy screen space, increase cognitive load, and distract us from the task we are currently trying to complete.

The hardest part is not closing a tab. It is deciding whether the tab might become important later.

Tab Debt gives users a safer way to let go:

Users can protect important URLs from cleanup.
The extension scans open tabs across Chrome windows.
Duplicate tabs are detected and removed.
Inactive tabs can be cleaned up.
Before closing tabs, the extension generates a short AI summary for each one.
The summaries are saved as reusable notes.
A JSON ledger of cleaned tabs is downloaded for future reference.
Users can reopen a saved tab whenever they need it again.
The goal is simple: reduce tab clutter while preserving the context users are afraid to lose.

Demo

The project is a Chrome extension, so the recommended demo is a screenshot showing :

Several duplicate and inactive tabs open.
Important URLs added to the protected list.
The Clean my tabs button being used.
Duplicate or stale tabs being removed.
AI-generated tab summaries appearing in the saved notes section.
The exported tab ledger being downloaded.
Code
The source code is available in the Tab Debt GitHub repository.

Before tab cleaning :-

After tab cleaning :-

Important parts of the implementation include:

Main dashboard
Tab cleanup logic
Protected-tab filtering
Background cleanup service
Gemma summarization integration
Chrome extension manifest
Storage utilities

Code
GitHub: https://github.com/Farkhanda-Dalal/TAB_DEBT

How I Built It
Tab Debt is built as a Manifest V3 Chrome extension using:

React
TypeScript
Vite
Chrome Extensions APIs
Chrome Storage API
Chrome Tabs API
Chrome Scripting API
Chrome Downloads API
Gemma 2 2B IT
Hugging Face Inference API

The interface is built with React and TypeScript. Vite provides the development and build workflow, while the Chrome Manifest V3 service worker handles the cleanup operation in the background.

The extension works in the following way:

The user adds important URLs to an “untouchable” list.
The background service queries open Chrome tabs.
Active tabs, protected URLs, extension pages, and tabs without usable URLs are excluded.
Remaining tabs are grouped by URL to identify duplicates.
Inactive or duplicate tabs are selected for cleanup.
The extension extracts a limited amount of visible page text.
The page title and extracted text are sent to Gemma.
Gemma produces a concise one-sentence summary.
The summary and original URL are stored as a saved note.
The tab is closed and a JSON ledger is downloaded so the user can recover the cleaned-up context.
We chose open-source and open-weight tools because the project is fundamentally about user control and reducing unnecessary complexity. React, TypeScript, Vite, and the Chrome extension platform provided a lightweight foundation. Gemma gave us a compact language model capable of summarizing pages without requiring us to build a model from scratch.

Why Open Innovation Matters
This is a problem many of our friends and teammates struggle with. We keep tabs open because we are afraid that closing one means losing an important idea, reference, task, or piece of research.

The result is a browser full of unfinished decisions.

Open innovation made it possible to combine several accessible technologies into a focused tool:

An open web extension platform for controlling browser tabs.
Open-source frontend tooling for building a lightweight interface.
An open-weight AI model for generating summaries.
Local browser storage for keeping protected URLs and saved notes.
A transparent JSON ledger that users can inspect and keep themselves.
A closed API could provide summarization, but open innovation gives us more flexibility over how the complete workflow is designed. We can decide what data is sent for summarization, how much page content is extracted, how protected tabs are handled, and how users recover their information after cleanup.

Most importantly, the user is not forced to choose between keeping every tab open and losing everything. Tab Debt preserves a lightweight memory of the tab before closing it.

The Lazy Payoff
Suppose a user has 20 tabs to review and spends approximately 3–4 minutes thinking through each tab:

20 tabs × 3 minutes = 60 minutes
20 tabs × 4 minutes = 80 minutes
That means manually deciding what to keep can consume approximately 1–1.3 hours.

With Tab Debt, the user can maintain a protected list, click one button, and let the cleanup service identify duplicates and inactive tabs. If the cleanup takes approximately 1–2 minutes, the estimated saving is:

58–79 minutes saved
Approximately 97.5%–98.3% less decision time
For a general estimate, Tab Debt can reduce the manual tab-review effort by roughly 95%–98%, depending on the number of tabs and how long the user normally spends evaluating each one.

The extension currently measures tabs scanned, duplicates closed, and protected tabs skipped. It reduces tab count and browser clutter, Therefore, the RAM benefit should be described as an expected reduction in browser resource pressure rather than a measured number.

Built by
Farkhanda · Dev: @7farkhanda
Misbah · Dev: @misbah_bagwan

Prize Categories
Gemma