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

What I Built

"Every codebase has ghosts. In nearly every enterprise repo and open-source project, there is a haunted file marked with // DO NOT TOUCH: NOBODY KNOWS WHY THIS WORKS. When the original author moves on, their domain knowledge vanishes into the ether. The code slowly rots, dependencies decay, and fear prevents anyone from touching it."

For Week 4 of Hacktoberfest — celebrating Halloween and Día de los Muertos — I built GitSéance: an Open-Source AI Code Necromancer that turns the graveyard of legacy code into an interactive, grounded séance.

   _____ _____ _______    _____ ______     _   _  _____ ______ 
  / ____|_   _|__   __|  / ____|  ____|   /\   | \ | |/ ____|  ____|
 | |  __  | |    | |    | (___ | |__     /  \  |  \| | |    | |__   
 | | |_ | | |    | |     \___ \|  __|   / /\ \ | . ` | |    |  __|  
 | |__| |_| |_   | |     ____) | |____ / ____ \| |\  | |____| |____ 
  \_____|_____|  |_|    |_____/|______/_/    \_\_| \_|\_____|______|

Instead of a generic linter, GitSéance coordinates The 4 Specialized Necromancy Agents:

💀 The Reaper Agent: Traverses the Git commit tree and file AST to identify abandoned, orphaned, and cursed code based on commit history, author turnover, and inline fear comments (hack, black magic, do not touch).
📊 The Oracle Agent (TabPFN-3.5): Synthesizes a 7-dimensional forensic feature vector and feeds it into Prior Labs' TabPFN tabular foundation model to predict calibrated file mortality risk.
🔮 The Medium Agent (Google Gemma): Channels the spirit of departed authors through Google's Gemma open-weight model (gemma-4-26b-a4b-it), generating first-person confessions, regret analyses, and modern revival blueprints.
🔍 The Searcher Agent (SerpApi): Queries live 2026 package registries and security databases to find modern drop-in replacements for abandoned dependencies and audit CVE advisories.

These agents power Interactive Séance Capabilities:

💬 Conversational Séance (Interactive Ghost Chat): Living developers can converse directly with the ghost in real time, asking why specific hacks were written and how to safely refactor them.
🔊 Neural Voice Deck (ElevenLabs): Gives the spirit an audible voice via neural text-to-speech with a synchronized Web Audio API waveform visualizer.
🪦 Official Post-Mortem Autopsy Certificates: Generates downloadable vintage ASCII death certificates detailing cause of demise, bus factor, and TabPFN mortality score.
📊 7D Tabular CSV Forensic Exporter: One-click download of the complete tabular feature dataset for offline TabPFN model exploration and auditing.
🛡️ Live GitHub SVG Mortality Badges: Dynamic shields endpoint (/api/badge/{owner}/{repo}.svg) for embedding live repository mortality scores in README files.

All of this is wrapped inside an authentic phosphor-green CRT Terminal interface with glass scanline curvature, CRT vignette, mechanical keystroke synthesis, and floating ectoplasm particles.

Demo

Live Production Deployment

🌐 Live Terminal: https://gitseance.onrender.com
💻 GitHub Repository: https://github.com/JaniDhruv/GitSeance
🛡️ Live Mortality Badge:

(Tip: When opening the live app, click the historic preset 🐍 flask-cache (Python 2 Fossil) to summon a 10-year-old fossil repository instantly!)

🖥️ Phosphor-Green CRT Terminal Interface

A visual walkthrough of the GitSéance terminal in action — glass scanlines, TabPFN mortality breakdown, live SerpApi modernization tree, and interactive Gemma ghost channeling:

The Séance Altar — Phosphor-green CRT dashboard featuring live agent status indicators, historic graveyard presets, and real-time streaming necromancy logs.

The Oracle (TabPFN-3.5) Scan — Bayesian code mortality probabilities, file risk categorization (Dead, Haunted, Orphaned), and Google Gemma code prophecy.

Channeled Ghost Transmission — Google Gemma persona channeling the departed author of Makefile, with ElevenLabs voice synthesis and real-time audio waveform visualizer.

Revival Blueprint & SerpApi Intelligence — Actionable modernization steps paired with live 2026 dependency alternatives queried in real time via SerpApi.

Code Autopsy Certificate — Official vintage ASCII post-mortem autopsy drawer detailing expiration date, recorded bus factor, and TabPFN mortality score.

Neural Voice Deck & MP3 Export — ElevenLabs spectral voice streaming with active waveform visualizer and 1-click MP3 download export.

Interactive Ghost Chat (Turn 1) — Interrogating the spirit of Thadeus Burgess on why legacy setup.py packaging was used.

Interactive Ghost Chat (Turn 2) — The ghost confesses to leaving a 2 AM emergency hack before a release: "Please, bury it for me."

Walkthrough: Summoning the Ghost of `flask-cache`

When scanning thadeusb/flask-cache (an ancient Python 2 caching library untouched since 2010):

The Reaper traverses the commit tree and flags Makefile as Clinically Dead (last touched 5,986 days ago).
TabPFN-3.5 evaluates the 7D feature vector (zero churn, 100% author turnover, missing unit tests) and predicts 80% Mortality Probability.
The Medium (Gemma 4) channels creator Thadeus Burgess, speaking in character: > "I am the lingering echo of Thadeus Burgess. On 2010-08-30T09:39:36Z, I pushed my final commit: 'R-0.1'. Then I walked away into the darkness, leaving Makefile behind to freeze in time."
ElevenLabs whispers the confession aloud (Roger — Ancient Architect voice preset), with real-time waveform visualization and 1-click ⬇️ Download MP3 export!
- 🎧 Listen to the Generated Audio: Download/Listen to the raw MP3 recording in my repository
SerpApi detects deprecated setup.py upload packaging commands and recommends modern replacements like build, twine, and pyproject.toml.
You open the Conversational Séance Chat and interrogate the ghost directly:
- YOU: "Why did you use setup.py upload instead of modern twine packaging?"
- GHOST (Thadeus Burgess): "Ah, you ask why I wrote it like this in Makefile... In those days, we were racing against the clock. The libraries you take for granted in 2026 didn't exist, and memory was scarce. It was the best compromise I could conjure."
- YOU: "Is there any secret hack or danger if I refactor or delete this Makefile today?"
- GHOST (Thadeus Burgess): "You noticed the scar, did you? Yes, I left that hack in Makefile at 2 AM before a release. I promised myself I would refactor it that weekend... but that weekend never came. Please, bury it for me."
You click "🪦 Print Death Certificate" and receive the official ASCII Post-Mortem Autopsy:

+========================================================================+
|                     💀 OFFICIAL CODE AUTOPSY 💀                        |
|                 DEPARTMENT OF SOFTWARE NECROMANCY                      |
+========================================================================+
| DECEASED ARTIFACT   : Makefile                                         |
| CHIEF ARCHITECT     : Thadeus Burgess                                  |
| DATE OF EXPIRATION  : 2010-08-30 (5,986 days inactive)                 |
| FINAL RECORDED WORDS: "R-0.1"                                          |
| TOTAL COMMITS       : 2 commits across file lifetime                   |
| RECORDED BUS FACTOR : 1 author(s) recorded in blame                     |
| HAUNTING STATUS     : DEAD                                             |
| TABPFN MORTALITY    : 80% Bayesian mortality risk                      |
| GHOST SEVERITY      : 0.80 / 1.00 index                                |
+------------------------------------------------------------------------+
| GHOST TESTIMONY:                                                       |
| "I am Thadeus, a fragment of logic drifting through a sea of           |
| deprecated dependencies. I linger in the shadows of these old          |
| Makefiles, waiting for a build that will never finish. Do not fear     |
| the silence; fear the unhandled exception."                            |
+------------------------------------------------------------------------+
| REVIVAL EFFORT      : REWRITE                                          |
| CERTIFICATE STAMP   : GITSEANCE FORENSIC ENGINE v1.0.0                 |
| AI RUNTIMES         : TABPFN-3.5 + GOOGLE GEMMA + ELEVENLABS           |
+========================================================================+

You click "📋 Copy Revival Blueprint" to grab an instant, actionable step-by-step migration blueprint:

REVIVAL BLUEPRINT FOR: Makefile
Summary: Transmute this ancient ritual into a modern, declarative build system.
Effort: rewrite

STEPS:
1. Transition from `setup.py` to a `pyproject.toml` configuration.
2. Replace the manual upload commands with `twine` for secure distribution.
3. Use the `build` module for generating distribution archives.
4. Implement a modern test runner like `pytest` instead of the legacy `setup.py test`.

Code

JaniDhruv / GitSeance

🔮 Every codebase has ghosts. GitSeance is an open-source AI code necromancer & forensics agent that scans legacy GitHub repos for dead files, predicts code mortality risk using TabPFN-3.5 tabular ML, channels the original author's spirit via Gemma 3 with ElevenLabs voice synthesis, and grounds modern revival patches via SerpApi.

🔮 GitSéance (GitSeance)

   _____ _____ _______    _____ ______     _   _  _____ ______ 
  / ____|_   _|__   __|  / ____|  ____|   /\   | \ | |/ ____|  ____|
 | |  __  | |    | |    | (___ | |__     /  \  |  \| | |    | |__   
 | | |_ | | |    | |     \___ \|  __|   / /\ \ | . ` | |    |  __|  
 | |__| |_| |_   | |     ____) | |____ / ____ \| |\  | |____| |____ 
  \_____|_____|  |_|    |_____/|______/_/    \_\_| \_|\_____|______|

An Open-Source AI Necromancer that brings "dead" GitHub repositories back to life — and predicts which files are about to die next.

Tagline: "Every codebase has ghosts. GitSéance channels them."

🌐 Live Demo: https://gitseance.onrender.com

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

📸 Production Gallery

🔮 Phosphor-Green CRT Terminal with Live AI Status & Streaming Necromancy Logs

📊…

View on GitHub

Released under the MIT License. Tested with 25 unit and integration tests passing on continuous integration.

How I Built It

GitSéance was engineered as an asynchronous multi-agent pipeline orchestrated by FastAPI:

                        ┌───────────────────────────────┐
                        │   Haunted Terminal (CRT UI)   │
                        └──────────────┬────────────────┘
                                       │
                                       ▼
                         FastAPI Orchestration Core
                                       │
        ┌──────────────┬───────────────┴───────────────┬──────────────┐
        ▼              ▼                               ▼              ▼
  💀 The Reaper   📊 The Oracle                  🔮 The Medium   🔍 The Searcher
 (Dead Code AST) (TabPFN-3.5 Mortality ML)       (Gemma LLM)     (SerpApi Web Search)
        │              │                               │              │
        ▼              ▼                               ▼              ▼
   GitHub API      Prior Labs API                 Google GenAI    SerpApi & CVEs

1. TabPFN-3.5: Bayesian Tabular Code Mortality Prediction

Instead of writing simplistic rule-based heuristics, I leveraged Prior Labs' TabPFN-3.5 — the tabular foundation model built on Prior-Data Fitted Networks.

The 7D Forensic Feature Vector

For every file in the target repository, GitSéance constructs a 7-dimensional tabular matrix:

# Extracted 7D Forensic Feature Vector for TabPFN-3.5
feature_vector = {
    "days_since_last_commit": m.days_since_last_commit,   # Temporal decay
    "total_commits": m.total_commits,                     # File depth
    "unique_authors": m.unique_authors,                   # Bus factor risk
    "bug_fix_commit_ratio": m.bug_fix_commit_ratio,       # Defect density
    "lines_ratio": (m.lines_added + 1) / (m.lines_del + 1), # Churn balance
    "has_tests": 1 if m.has_tests else 0,                 # Test presence
    "churn_velocity": m.churn_velocity,                   # Monthly change rate
}

Ground-Truth Calibration & Edge Case Resolution

TabPFN uses in-context Bayesian inference over a reference support matrix (X_train, y_train) calibrated on 50 historic open-source code artifacts (25 deceased fossils from archived repositories vs. 25 actively maintained modules from fastapi, pydantic, and requests).

Why TabPFN beats naive heuristics:
A naive linter looks at a file untouched for 3 years and blindly flags it as "dead". But consider a core mathematical utility (e.g. slugify.py or crc32.py):

days_since_last_commit: 1,100 days
bug_fix_commit_ratio: 0.02 (almost zero defects)
has_tests: True (100% branch coverage)
churn_velocity: 0.00 (stable)

A naive rule flags this as dead (100% false positive). TabPFN correctly evaluates the high test sentinel and near-zero defect ratio, classifying it as "FROZEN / STABLE" (Mortality: 18%) rather than DEAD. Conversely, a file untouched for 180 days with a sole departed author and a 60% bug-fix ratio is caught by TabPFN as "HIGH MORTALITY RISK" (78%).

To make this completely transparent:

📊 7D Tabular CSV Export: Users and judges can click "📊 Export CSV" to download the raw feature distribution (tabpfn-<repo>-forensic-dataset.csv).
🔌 Native MCP Server (backend/mcp_server.py): Fulfills Prior Labs' explicit preference by exposing tabpfn_predict_mortality directly as a Model Context Protocol tool for Cursor, Claude Desktop, and Copilot!

2. Google Gemma: Spiritual Persona Channeling & Thought Token Parsing

The Medium agent runs Google's Gemma open-weight model (gemma-4-26b-a4b-it) via the google-genai SDK.

The Thought-Token Parsing Challenge

gemma-4-26b-a4b-it features internal chain-of-thought reasoning. When generating spiritual monologues, the model outputs thinking tokens before emitting character dialogue. If parsed naively, the internal reasoning tokens can consume the entire output budget or bleed into the monologue.

I engineered a dedicated candidate extractor:

@staticmethod
def _extract_text(response) -> str:
    """Extract content text from Gemma response, filtering thought tokens."""
    if not response:
        return ""
    # 1. Prioritize candidate parts inspection to filter out internal chain-of-thought tokens
    if hasattr(response, "candidates") and response.candidates:
        candidate = response.candidates[0]
        if hasattr(candidate, "content") and hasattr(candidate.content, "parts"):
            actual_parts = [
                p.text for p in candidate.content.parts
                if not getattr(p, "thought", False) and getattr(p, "text", None)
            ]
            if actual_parts:
                return "".join(actual_parts).strip()
    # 2. Fallback to response.text if candidate parts are not directly accessible
    if hasattr(response, "text") and response.text:
        return response.text.strip()
    return ""

Grounding the Persona

The ghost persona is strictly grounded in git history and inline comments:

SEANCE_SYSTEM_PROMPT = """You are the ghost of a software developer. You died — meaning you left this project — 
and your spirit now haunts the codebase. You are being summoned in a séance to explain the code you left behind.

When channeled, you will:
1. Explain WHY you wrote the code the way you did (constraints, tech landscape at the time)
2. Confess what you wish you had done differently (unfinished business)
3. Give concrete, modern advice for reviving or replacing the code
Speak with the voice of someone who lived through the decisions. Keep it vivid, personal, and under 300 words."""

Living developers can even hold a Conversational Séance (POST /api/seance/chat) to ask follow-up questions directly to the ghost!

3. SerpApi: Live 2026 Dependency Intelligence

The Searcher agent parses package declarations (requirements.txt, package.json, Gemfile, go.mod) and uses SerpApi to query real-time migration paths, modern drop-in replacements, and live CVE security databases.

4. ElevenLabs: Neural Audio Synthesis & 1-Click MP3 Export

Séance transmissions are rendered into speech using ElevenLabs Neural TTS (eleven_multilingual_v2), backed by a Web Audio API procedural synthesis engine that emulates retro mechanical keyboard switches and low-frequency resonant summoning hums:

5 Archetypal Spectral Voices: Roger (Ancient Architect), Sarah (Soft Echo), Laura (Ethereal Narrator), Charlie (Elder Storyteller), and Aria (Spectral Whisper).
1-Click MP3 Export: Living developers can click "⬇️ Download MP3" to export the synthesized ghost audio directly to disk.
🎧 Actual Channeled Recording: Listen to the ghost of Thadeus Burgess explain Makefile.

5. GitHub Copilot Deep Integration & GitHub Actions Automation

I built full Copilot and GitHub Actions automation natively into the repository:

.github/copilot-instructions.md: Custom repository instructions explaining the 4-agent necromancy architecture, TabPFN 7D schema, and Pydantic models.
.github/prompts/: 3 reusable IDE prompt templates (/resurrect-file, /tabpfn-mortality, /dep-modernize).
.github/workflows/ci.yml: Multi-OS CI testing matrix across Ubuntu and Windows with 25 unit and integration tests passing.
.github/workflows/cd.yml: Continuous Deployment pipeline that verifies live production health (/health), probes SVG badges, and outputs formatted Markdown summaries.
.github/workflows/copilot-review.yml: Automated GitHub Action that reviews contributor PRs for fear comments (hack, do not touch) and posts automated review checklists.

6. What Broke Along the Way (Engineering Scars)

Building GitSéance wasn't smooth sailing. Here are three real engineering friction points I wrestled with:

1. The Ghost That Thought Too Much (Gemma Thought Tokens)

When I first connected gemma-4-26b-a4b-it, my API calls frequently returned empty text. Digging into the raw response object, I discovered that Gemma's reasoning mode was generating extensive internal thought traces (part.thought = True) that exhausted the token budget before emitting the final text. Standard SDK accessors like response.text evaluated to None when thought blocks were present. I had to write a low-level AST extractor to walk response.candidates[0].content.parts and isolate the unmasked dialogue.

2. GitHub REST API Blame Rate Limits

Traversing commit histories across 50 files for a repository burns through GitHub’s unauthenticated 60 req/hr rate limit in less than 30 seconds. To solve this, I implemented:

Concurrent chunking (asyncio.gather with a bounded batch size of 8).
AST scannable extension filters (skipping SVGs, binaries, and lockfiles).
Deterministic forensic fallback snapshots for historic graveyards (flask-cache, jquery-color) so the app never fails even if a user arrives without a GitHub PAT.

3. Python 3.11 Backslash Restrictions in SSE Streaming

During real-time Server-Sent Events (SSE) implementation, Python 3.11 threw unexpected SyntaxError: f-string expression part cannot include a backslash when formatting JSON data payloads inline. I had to refactor the streaming generator to serialize messages into explicit intermediate buffers before formatting data: {msg}\n\n.

Why Does Open Innovation Matter?

"What did open innovation make possible that a closed API wouldn't?"

Building GitSéance illuminated why open-weight models and open AI infrastructure are vital:

Air-Gapped Code Privacy & Zero IP Leakage:
Proprietary codebases contain confidential business logic, security credentials, and trade secrets. Organizations cannot paste their entire git trees into closed third-party cloud APIs. Because Gemma and TabPFN-3.5 are open-weight, GitSéance can run entirely offline on an air-gapped machine. Your code never leaves your local hardware.
Auditable, Reproducible Risk Modeling:
When an algorithm declares that a mission-critical banking module has a "98% mortality risk," developers deserve to understand why. Closed proprietary scoring systems are black boxes that shift silently between model versions. TabPFN's Bayesian foundation model enables deterministic, reproducible tabular inference that can be inspected, benchmarked, and trusted.
Resilience Against API Deprecation:
Closed AI services frequently sunset endpoints, alter system prompts, or raise token costs. With open-weight AI, your necromancer works with the internet turned off. If the power goes out, the ghosts remain accessible.
Community Fine-Tuning & Custom Personas:
Open weights allow teams to fine-tune Gemma on their own internal commit histories, Jira tickets, and architectural decision records (ADRs), turning company alumni into permanent institutional memory.

The Spirit of It

Software engineering has a quiet tragedy: developers pour months of their lives into writing elegant systems, but technology moves so fast that within a few years, their work is labeled "legacy" and discarded.

In the tradition of Día de los Muertos, the dead are never truly gone as long as they are remembered. When GitSéance channels the author of an abandoned decade-old file, it doesn't mock the code for being outdated. It gives that developer a voice to say:

"I wrote this when memory was scarce and deadlines were tight. It served its purpose. Now, here is how you can carry the torch forward."

That shift in perspective — from dreading legacy code to honoring the human effort behind it — is the true spirit of GitSéance.

Prize Categories

🏆 Top Prize — Overall Challenge Winner
🚀 Best Use of Render — Full-stack containerized deployment running both the FastAPI necromancy engine and the CRT frontend live in production at https://gitseance.onrender.com via render.yaml.
📊 Best Use of TabPFN (Prior Labs) — TabPFN-3.5 tabular foundation model for calibrated Bayesian code mortality prediction across a 7D feature vector, paired with a native Model Context Protocol (MCP) Server (backend/mcp_server.py) and a 1-click forensic CSV dataset exporter.
🔮 Best Use of Gemma — Open-weight gemma-4-26b-a4b-it model powering the Medium agent for grounded historical persona channeling, thought-token parsing, and real-time interactive conversational séances.
🤖 Best Use of GitHub Copilot — Custom repository instructions (.github/copilot-instructions.md), 3 reusable IDE prompt templates (.github/prompts/), automated PR reviewer GitHub Action auditing fear comments (.github/workflows/copilot-review.yml), and multi-OS CI/CD automation.
🔊 Best Use of ElevenLabs — Neural TTS speech synthesis giving departed authors audible voices with 5 distinct spectral archetypes, real-time Web Audio API waveform visualizer, and 1-click MP3 audio export.
🔍 Best Use of SerpApi — Real-time 2026 dependency intelligence, discovering modern drop-in replacements for deprecated packaging, and live security CVE audits.

Built with passion, caffeine, and ectoplasm by Dhruv Jani.

StackFeed

Every Codebase Has a '// DO NOT TOUCH' File. I Built an AI Necromancer to Summon the Ghost of the Developer Who Wrote It 💀🔮