I Built an AI That Listens to the Ghosts of Forgotten GitHub Repositories 👻

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

Open-source projects rarely disappear all at once.

They become quiet.

Commits slow down. Issues remain unanswered. Documentation stops matching reality. Unfinished ideas survive inside TODO comments, abandoned branches, and old release notes.

The code is still there—but the context begins to disappear.

I built GhostCommits to investigate those surviving traces.

What I Built

GhostCommits is a local, open-source AI software archaeologist.

Give it a public GitHub repository URL, and it reconstructs an evidence-backed picture of the project:

1. It collects public repository metadata.
2. It safely mines bounded Git history.
3. It examines issues, README content, commits, contributors, and TODO markers.
4. It converts observations into individually identified evidence records.
5. It asks Gemma to interpret only that evidence.
6. It rejects unsupported model claims.
7. It produces an autopsy, resurrection blueprint, evidence report, and digital epitaph.

I interpreted Ghost in the Machine as the history that remains trapped inside an inactive codebase.

The “ghost” is not a fictional maintainer personality. It is the repository’s surviving evidence: the last commit, unresolved issue, unfinished comment, archived status, and development pattern.

GhostCommits gives those traces a voice without pretending to know more than the evidence can support.

Demo

In the demonstration, I investigate a real public repository rather than loading a fabricated result.

GhostCommits moves through five views:

• Autopsy — activity history, repository health signals, and verified evidence
• Whispers — Gemma interpretations linked to evidence IDs
• Revive — a sequenced resurrection blueprint
• Epitaph — a downloadable memorial card
• Raw Evidence — the complete inspectable JSON report

The application also supports a bundled offline report so the interface remains demonstrable when GitHub is unavailable, but the primary workflow analyzes real repositories.

Code

The complete project is open source:

svefn-g-englar / GhostCommits

GhostCommits

Every abandoned repository has a story. GhostCommits finds the evidence, separates fact from inference, and turns the surviving trail into a safe resurrection plan.

GhostCommits is a competition-ready, open-source AI software archaeologist. It combines deterministic Git/GitHub mining with schema-constrained Gemma inference. Facts never come from the language model; the model may only interpret a validated evidence packet, and unsupported evidence IDs are rejected.

Standout features

• The Last Heartbeat — real GitHub metadata plus bounded Git history mining.
• Whispers from the Past — Gemma produces structured, evidence-linked findings.
• Claim Firewall — unsupported citations never reach the interface.
• Resurrection Blueprint — a safe, contributor-ready recovery sequence.
• Digital Epitaph — a shareable PNG memorial generated from verified facts.
• Adversarial safety — public GitHub only, bounded clone, no code execution.

Product tour

01 · Autopsy

The activity heartbeat and signal profile expose the repository's observable development history, while every displayed conclusion remains connected…

View on GitHub

The repository includes:

• The complete Streamlit application
• GitHub and Git analysis modules
• Local Gemma integration through Ollama
• Evidence and claim validation
• Automated tests
• A reproducible three-repository evaluation
• Example output and product screenshots
• MIT license and local setup instructions

How I Built It

GhostCommits separates deterministic software mining from AI interpretation.

That separation became the most important architectural decision in the project.

1. Safe repository collection

The GitHub client accepts only public github.com repository URLs.

It collects repository metadata, languages, contributors, issues, and commit information through the GitHub API. Errors such as rate limits, inaccessible repositories, timeouts, malformed responses, and DNS failures are converted into understandable messages.

Deep archaeology uses a bounded shallow clone. Clone depth, scanned file count, blob size, repository size, and individual text-file size are limited.

Submodules are not initialized, and repository scripts are never executed.

GhostCommits treats repository content as untrusted evidence—not instructions.

2. Evidence before inference

Every observation becomes a normalized evidence record.

A record contains:

• A stable evidence ID such as E-001
• A precise claim
• Its observed value
• A source URL
• The observation timestamp
• Its evidence category

For example, GhostCommits does not send Gemma a vague statement saying that a repository “looks abandoned.”

It supplies observations such as:

• The repository’s archived status
• Days since its last recorded push
• Open issue count
• Primary language
• Sampled commit activity
• Selected TODO markers
• Source links for every observation

Facts come from GitHub and Git. Gemma is responsible only for interpretation.

3. Gemma as the interpreter

GhostCommits runs Gemma 3 1B locally through Ollama.

Gemma receives a compact evidence packet and must return structured JSON containing:

• A concise digital epitaph
• Evidence-grounded findings
• Confidence values
• Uncertainty notes
• Referenced evidence IDs

This is not simply a spooky text generator.

Gemma’s purpose is to connect multiple technical observations into a readable explanation and identify practical restoration priorities.

4. The claim firewall

Language models can produce convincing statements that are not supported by their input.

GhostCommits therefore implements a claim firewall to validate model-generated findings before displaying them.

If a finding references an evidence ID that does not exist, it is removed. Confidence values are normalized, malformed findings are rejected, and uncertainty remains visible in the interface.

This validation reduces the risk of unsupported claims entering the final report. However, a valid evidence reference does not automatically guarantee that an AI-generated interpretation is factually correct. The system therefore prioritizes traceability and transparency rather than claiming to eliminate hallucinations entirely.

The hardest part of this project was not making Gemma sound intelligent.

It was deciding when Gemma should not be allowed to speak.

5. Resurrection instead of automation

GhostCommits does not execute repository code, modify the project, or create pull requests.

Instead, it produces a contributor-ready recovery sequence:

1. Preserve the surviving evidence.
2. Reconstruct an isolated historical toolchain.
3. Validate installation and tests.
4. Triage unresolved work.
5. Document compatibility findings.
6. Prepare the project for new contributors.

This keeps the recommendations actionable without pretending that an automated agent can safely revive an unfamiliar project by itself.

Testing the Investigation

I evaluated GhostCommits on three deliberately different public repositories:

• One officially archived repository
• One inactive but unarchived repository
• One actively maintained repository

I measured lifecycle classification, evidence URL validity, claim support, recommendation actionability, AI usage, and total investigation time.

The recorded evaluation produced:

• 3/3 lifecycle classifications correct
• 50/50 evidence URLs reachable
• 3/3 rendered findings supported by valid evidence IDs
• 18/18 resurrection steps considered actionable
• 60.60 seconds mean end-to-end investigation time
• Gemma used for every measured case rather than fallback output

The evaluation script, methodology, limitations, and raw results are committed to the repository.

Three repositories are not a statistically broad benchmark. The purpose of this evaluation is to make the project’s claims inspectable rather than implying universal accuracy from a polished demonstration.

The Moment It Landed

The moment GhostCommits felt real was not when the interface became spooky.

It was when I investigated an officially archived repository and watched separate fragments become a coherent case file.

An archived flag, years of inactivity, unresolved issues, commit history, and surviving TODO comments stopped looking like disconnected API fields. Together, they described what remained technically recoverable.

Gemma produced an interpretation—but the interface could still show exactly why that interpretation was allowed to appear.

That was the moment the project changed from an AI-themed dashboard into a tool I could trust.

Why Open Innovation Matters

Running Gemma locally is fundamental to GhostCommits.

It is not an interchangeable decoration added to qualify for an AI challenge.

Local, open-weight inference means:

• Repository evidence does not need to be sent to a closed inference service.
• The prompt and expected output schema can be inspected.
• The model can be replaced or upgraded.
• Experiments can be reproduced without per-request API charges.
• The inference layer can continue working even if a commercial endpoint disappears.
• Contributors can examine both the AI behavior and the validation surrounding it.

A live investigation still requires GitHub access to collect public repository data. After that evidence packet has been created, the interpretation runs locally through Ollama.

This architecture also made a transparent fallback possible. If Ollama is unavailable, GhostCommits switches to a deterministic evidence-based analysis and clearly labels that mode. It never presents fallback text as successful Gemma output.

Open innovation matters here because software archaeology should remain inspectable.

A tool investigating the history of open-source projects should not hide its own reasoning behind an inaccessible service.

Challenges and Lessons

Inactivity is not motive

A repository may be quiet for many reasons.

GhostCommits can observe that no push occurred for 900 days. It cannot conclude that a maintainer lost interest, became unavailable, or considered the project a failure unless a cited source explicitly says so.

This distinction shaped the entire evidence system.

Small models need boundaries

Gemma 3 1B can produce useful interpretations on modest local hardware, but smaller models benefit enormously from constrained inputs, structured output, and post-generation validation.

The claim firewall improved reliability more than simply asking the model to “be accurate.”

External services fail

During development, GitHub access could fail because of DNS issues, rate limits, timeouts, or malformed responses.

Instead of treating those failures as edge cases, I made them part of the product experience. GhostCommits provides actionable errors and an offline workflow rather than collapsing into a stack trace.

Presentation still matters

The technical core needed to remain serious, but the challenge invited a spooky interpretation.

I used an oxblood folk-horror palette, archival typography, flickering signals, EVP-inspired visualizations, and case-file details. The interface supports the story without hiding evidence behind decoration.

Limitations

GhostCommits intentionally has boundaries:

• It supports public GitHub repositories only.
• GitHub rate limits still apply.
• Git history is bounded and sampled.
• It does not execute repository code.
• It cannot determine private maintainer intent.
• Gemma 3 1B can still produce weak or malformed interpretations.
• Local AI requires Ollama and sufficient system memory.
• The current evaluation contains only three repositories.
• Resurrection plans still require human technical judgment.

These limitations are features of the trust model, not unfinished promises of full autonomy.

The Spirit of It

GhostCommits treats inactive software less like digital waste and more like an archive.

The objective is not to pretend that code is alive or manufacture stories about the people who wrote it.

It is to preserve what can still be proven, acknowledge what has been lost, and make restoration possible.

Every abandoned repository has a story.

GhostCommits makes sure the evidence gets to tell it.

Prize Categories

• Best Use of Gemma -- GhostCommits uses Gemma 3 1B locally through Ollama to interpret repository evidence and generate structured, evidence-linked findings.

Final Thoughts

GhostCommits started with a simple question: what can abandoned software still tell us?

By combining Git history, structured evidence, and open-weight AI, I built a tool that helps developers uncover forgotten projects without inventing their stories.

The code may be silent. The story isn't.

Unearth the past. Revive the code. 👻

Source code: https://github.com/svefn-g-englar/GhostCommits