I Built RepoSéance 👻: Bringing Forgotten Codebases Back to Life with Local AI

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

What I Built

I built RepoSéance 👻, a local AI code archaeology tool that helps developers rediscover the story behind forgotten repositories.

Have you ever opened an old project and wondered why you created a particular file, what you left unfinished, or what you were planning to build next?

Repositories accumulate TODOs, FIXMEs, HACK markers, undocumented decisions, and unfinished ideas. When we return to them months later, the original context can feel lost.

RepoSéance helps bring that context back.

It scans a repository for unfinished-work markers, examines available project documentation and Git history, and uses an open-weight AI model to turn the collected evidence into a readable report.

The report helps developers understand:

• What a project appears to do.
• Which unfinished tasks deserve investigation.
• What the available Git history tells us.
• What practical steps could help revive the project.

It can also export the findings as a Markdown report for future reference.

I chose the name RepoSéance because the experience feels a little like summoning the ghosts of old code: recovering clues about decisions and ideas that might otherwise be forgotten.

Demo

Project demo: https://drive.google.com/file/d/1uiXG9L_QJ0nMp-QOL2Fj3AXKK3Nie9Oc/view?usp=sharing

The demo shows RepoSéance scanning a repository, presenting its findings, generating an AI-assisted report, and helping identify the next steps.

GitHub Actions: The repository also includes an automated test workflow.

View GitHub Actions

Code

GitHub repository: https://github.com/Shreyansh2025/repo-seance

The repository includes the application code, frontend, FastAPI backend, tests, setup instructions, and GitHub Actions workflow.

The project is designed to inspect repository evidence without executing or modifying the code being inspected.

How I Built It

I built RepoSéance using:

• Python for repository scanning and application logic.
• FastAPI for the backend API.
• Ollama to run the AI model locally.
• Gemma 3 1B for AI-assisted repository analysis.
• HTML, CSS, and JavaScript for the interface.
• Git to examine repository history.
• GitHub Actions to automate testing.

The workflow is straightforward:

1. The user selects a local repository.
2. RepoSéance collects evidence from available documentation, unfinished-work markers, and Git history.
3. The application sends the collected context to Gemma through the local Ollama API.
4. Gemma generates a structured explanation and suggests practical next steps.
5. The application presents the findings and allows the report to be exported as Markdown.

One important lesson came from testing the project: an AI-generated explanation can sound convincing even when the available evidence does not support it.

I encountered this problem when an early report described Git commits that were not present in the sample repository. I corrected the history handling and added regression tests so that the application would not present unsupported commit history as fact.

The project now has 12 passing automated tests in my local test run. I also published the repository with a GitHub Actions workflow to automate testing.

This reinforced an important principle for me: AI-assisted code analysis should distinguish what the application actually found from what the model merely infers.

Why Does Open Innovation Matter?

I chose an open-weight model because I wanted RepoSéance to be useful without requiring every repository analysis to go through a third-party AI API.

Running Gemma locally through Ollama gives the application several advantages.

Privacy: Source code and repository notes may contain sensitive information. Local inference lets the application analyze that material without sending it to an external AI model API.

Offline capability: After the model and dependencies have been downloaded, the analysis can run without an internet connection, provided the local services are running.

Model control: Developers can experiment with compatible models and adjust the analysis workflow as the project evolves.

Reproducibility and learning: I can inspect how repository evidence is collected, what context reaches the model, and how its output is presented instead of treating the AI service as a black box.

There are trade-offs. A local model uses the computer's memory and processing power, and it may misunderstand code or suggest incorrect next steps. Repository findings need to be checked against the actual files and history.

For RepoSéance, open innovation is not just about using a model with open weights. It is about having control over the workflow, the data, and how the tool can evolve.

The Spirit of It

Every abandoned repository has a small story.

Maybe it was a weekend experiment. Maybe it was an ambitious idea that ran out of time. Maybe it contains a TODO that made perfect sense when it was written but has become mysterious months later.

The code remains, but the context fades.

RepoSéance is my attempt to recover some of that lost context. Rather than pretending AI can know everything about a project's past, it uses the available evidence to help developers reconstruct the story and decide what to do next.

The project fits the Ghost in the Machine theme because the ghosts aren't supernatural. They are unfinished ideas, forgotten decisions, and clues left behind in code.

Sometimes, bringing a project back to life begins with one small question:

What was I trying to build here?

Prize Categories

• Best Use of Gemma — $200: Gemma is the core model used to turn repository evidence into an explanation and revival plan.
• Best Use of GitHub Copilot — $100: The project includes a GitHub Actions workflow for automated testing, which aligns with the category's stated automation option.

Built for Hacktoberfest 2026 — Week 4: Ghost in the Machine.

devchallenge #hf26challenge #gemma #opensource #python