Submission week 4

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

What I Built

Séance.dev lets you summon an archived open-source repo and talk to its ghost.

You paste a GitHub URL. The app pulls the repo's commits, issues, PR threads and docs, then lets you ask questions like "Why did you stop development?" or "What bug did you never fix?" The ghost answers using only what the repo left behind, and every claim links to the commit, issue or comment it came from. If the record doesn't cover your question, it says so instead of guessing.

There's also a Resurrect button. Pick an open issue and it drafts a patch plan: likely cause, files involved, fix steps, risks, and a test idea, each tied to evidence from the repo's own history.

For the theme, I took "Ghost in the Machine" literally. Abandoned open-source projects are ghosts: the code is still there, but the people and the reasoning behind it are gone. Most of that reasoning lives in old issue threads that nobody reads. Séance.dev brings it back to the surface.

One thing to be upfront about: this is a grounded simulation built from public repo history. It is not the real maintainers, and the ghost never invents quotes or opinions for them.

Demo

• Live demo / video:
• Pre-loaded repos in the demo: [repo 1], [repo 2]
• The demo runs with Wi-Fi off after ingestion: [timestamp in video]

Code

[Embed GitHub repo here:

AVENGERSTHE2102 (Aditya Sabnis) · GitHub

AVENGERSTHE2102 has 44 repositories available. Follow their code on GitHub.

    <div class="color-secondary fs-s flex items-center">
        <img
          alt="favicon"
          class="c-embed__favicon m-0 mr-2 radius-0"
          src="https://github.githubassets.com/favicons/favicon.svg"
          loading="lazy" />
      github.com
    </div>
  </div>
</div>

]

Setup is [N] commands, listed in the README.

How I Built It

Everything in the core loop is open source and runs locally:

• LLM: [Qwen / Llama model + size] served through Ollama
• Embeddings: [nomic-embed-text or other] via Ollama
• Retrieval: [SQLite + vector extension / Elasticsearch] storing chunks with metadata (type, id, date, author)
• Backend: FastAPI, streaming answers over SSE
• Frontend: [React / plain JS] with candle-flicker and fog effects in CSS only

How it works:

1. The ingestor pulls commits, issues, PRs and docs from the GitHub API and caches them to disk.
2. Commits become one chunk each. Issues and PRs are chunked as title + body plus grouped comment threads. Docs are split by heading.
3. At question time, the top-k chunks are retrieved and handed to the model with strict grounding rules: answer only from context, cite every factual claim, say "the record is silent" when retrieval is weak.
4. A validation step drops any citation whose id wasn't actually in the retrieved set.
5. Resurrect runs a second pipeline: fetch the issue thread, retrieve related commits and PRs, and produce a structured plan.

What I'd flag honestly: [one real limitation you hit, e.g. small-model answer quality, long issue threads, rate limits, and how you handled it].

Why Does Open Innovation Matter?

• It works with the lights off. After ingestion, nothing needs the network. A project about preserving things that disappear shouldn't depend on a service that can disappear.
• Your code stays yours. Pointing a hosted API at a private fork or a client's old codebase means sending it to someone else's server. Here it never leaves the machine.
• You can swap the brain. I compared [models] on [N] test questions. One config line changes the model, so the project isn't tied to one vendor's pricing or deprecation schedule.
• It costs nothing to run. Ingesting hundreds of issues and asking hundreds of questions has no per-token bill.

With a closed API, the same idea would work for a weekend, then break the day the model is retired or the pricing changes. That's the exact failure the project is about.

My Agent Session

[Embed your DevRelay session here with the agent_session tag, or link to it.]

The Spirit of It

Open-source projects don't usually die with a bang. A maintainer gets busy, the issues pile up, and the last commit is from two years ago. The decisions, the dead ends and the "we should fix this someday" comments stay buried in threads.

Built solo by Aditya Sabnis