The Source Availability Scanner

What you’re building

You want to start a retro game remake company. The first question for any target IP isn’t “can I get the rights?” — it’s “what source material actually exists?” Because the answer determines everything: your engineering timeline, your budget, your negotiating leverage, and whether you’re rebuilding from scratch or standing on someone else’s foundation.

BloodRayne? No public source code. Terminal Reality is defunct. Ziggurat Interactive owns the rights but hasn’t released anything beyond the Terminal Cut editions. That means a full clean-room rebuild. Legacy of Kain: Soul Reaver? There’s an active decompilation project on GitHub. Oni? Bungie’s source has been partially reconstructed by the community. Each of these facts changes your entire business case.

Right now this research lives in your head, or maybe in a messy spreadsheet. You’re about to turn it into a structured database with a CLI that lets you add IPs, update their status, and generate a formatted report showing exactly what you’re working with across your entire target list.

ℹSoftware pattern: Research database with CLI interface

Input data + structured schema + query/report commands = organized research. This same pattern works for competitor analysis, market research, or any situation where you’re collecting structured facts about multiple targets. The techniques here transfer directly.

The showcase

Here’s what the finished tool does:

Pre-loaded database: Ships with research on 6 target IPs — BloodRayne, BloodRayne 2, Legacy of Kain: Soul Reaver, Primal, Darkwatch, and Oni
Source status categories: Each IP is classified as official-release (developer released source), decompilation (community reverse-engineering), mod-sdk (official modding tools), or nothing (no source material available)
Detailed records: For each IP — original developer, current rights holder, acquisition date, source status, community projects (URLs), mod tools available, and your notes
Add command: node src/index.js add "Game Name" walks you through adding a new IP interactively
Update command: node src/index.js update "BloodRayne" --status decompilation --notes "New decomp project found" to update existing records
Report command: node src/index.js report generates a formatted Markdown report with a summary table and detailed breakdown per IP
Output: JSON database file (source-db.json) persists between runs, plus Markdown report (source-report.md)

Everything runs locally. Your target list and business research stay on your machine.

The prompt

Open your terminal, create a project folder, start your AI CLI tool, and paste this prompt:

Build a Node.js CLI tool called source-scanner that tracks source code
availability for retro game IPs being evaluated for remake potential.

PROJECT STRUCTURE:
source-scanner/
  package.json
  src/
    index.js          (CLI entry point using Commander.js)
    database.js       (JSON file read/write operations)
    report.js         (Markdown report generator)
  data/
    source-db.json    (pre-loaded game database)

REQUIREMENTS:

1. CLI INTERFACE (src/index.js)
   Commands:
   - list                        Show all IPs in the database as a table
   - report                      Generate full Markdown report to output/source-report.md
   - add "<name>"                Add a new IP with interactive prompts
   - update "<name>" [options]   Update an existing IP record
   - search "<query>"            Search IPs by name, developer, or rights holder

   Update options:
   --status <official-release|decompilation|mod-sdk|nothing>
   --rights-holder "<name>"
   --notes "<text>"
   --community-url "<url>"

2. DATABASE SCHEMA (data/source-db.json)
   Each entry:
   {
     "name": "Game Title",
     "originalDeveloper": "Studio Name",
     "originalPublisher": "Publisher Name",
     "currentRightsHolder": "Current Owner",
     "rightsAcquisitionDate": "YYYY-MM or 'unknown'",
     "rightsAcquisitionDetails": "How and from whom rights were acquired",
     "sourceStatus": "official-release | decompilation | mod-sdk | nothing",
     "communityProjects": [
       { "name": "Project Name", "url": "https://...", "status": "active | stale | archived" }
     ],
     "modTools": "Description of any official mod SDKs or editors, or 'none'",
     "engineInfo": "Original engine name and any known details",
     "platforms": ["PS2", "Xbox", "PC"],
     "releaseYear": 2002,
     "remakeNotes": "Your analysis notes",
     "lastUpdated": "2026-03-30"
   }

3. PRE-LOADED DATA (6 entries):

   a. BloodRayne (2002)
      - Developer: Terminal Reality (defunct, closed ~2013)
      - Publisher: Majesco Entertainment
      - Rights: Ziggurat Interactive (acquired from Majesco, June 2020)
      - Source status: nothing
      - Engine: Infernal Engine (proprietary, Terminal Reality)
      - Platforms: PS2, Xbox, GameCube, PC
      - Notes: No source code release. Ziggurat released Terminal Cut editions
        (2020-2021) with minor graphical updates -- likely contracted work from
        existing binaries, not source access. No known decompilation efforts.
        Clean-room rebuild required.

   b. BloodRayne 2 (2004)
      - Developer: Terminal Reality
      - Publisher: Majesco Entertainment
      - Rights: Ziggurat Interactive (June 2020, same acquisition)
      - Source status: nothing
      - Engine: Infernal Engine v2
      - Platforms: PS2, Xbox, PC
      - Notes: Same situation as BloodRayne 1. Terminal Cut edition released.
        No source access. Shares engine lineage with BR1.

   c. Legacy of Kain: Soul Reaver (1999)
      - Developer: Crystal Dynamics
      - Publisher: Eidos Interactive
      - Rights: Crystal Dynamics / Embracer Group (via Square Enix sale, 2022)
      - Source status: decompilation
      - Community projects: [{ name: "Soul Reaver Decomp", url: "https://github.com/Flavor-of-Code/soul-reaver-decomp", status: "active" }]
      - Engine: Custom (Crystal Dynamics proprietary)
      - Platforms: PS1, Dreamcast, PC
      - Notes: Active community decompilation project. Embracer acquired Crystal
        Dynamics from Square Enix in 2022. IP status in flux after Embracer
        restructuring. Decompilation provides technical reference but does not
        grant rights.

   d. Primal (2003)
      - Developer: SCE Cambridge Studio (now Guerrilla Cambridge, defunct 2017)
      - Publisher: Sony Computer Entertainment
      - Rights: Sony Interactive Entertainment
      - Source status: nothing
      - Engine: Custom (SCE Cambridge proprietary)
      - Platforms: PS2
      - Notes: Sony first-party IP. No source release. Studio closed in 2017.
        Available on PS4/PS5 via PS2 Classics emulation. Sony rarely licenses
        dormant IP to third parties.

   e. Darkwatch (2005)
      - Developer: High Moon Studios
      - Publisher: Capcom (NA), Ubisoft (PAL)
      - Rights: Unclear -- likely High Moon Studios / Activision (High Moon
        acquired by Activision 2010, now part of Microsoft via ABK acquisition)
      - Source status: nothing
      - Engine: Custom (High Moon proprietary)
      - Platforms: PS2, Xbox
      - Notes: Rights chain complicated by Activision acquisition of High Moon
        and subsequent Microsoft acquisition of Activision Blizzard King (2023).
        Publishing split between Capcom and Ubisoft adds complexity. No source
        release, no community projects. Rights negotiation would require
        Microsoft legal.

   f. Oni (2001)
      - Developer: Bungie (pre-Microsoft acquisition)
      - Publisher: Gathering of Developers / Take-Two Interactive
      - Rights: Take-Two Interactive (publishing), Bungie/Microsoft (unclear on IP)
      - Source status: decompilation
      - Community projects: [{ name: "Oni Community Edition", url: "https://wiki.oni2.net", status: "active" }]
      - Engine: Custom (Bungie proprietary)
      - Platforms: PS2, Mac, PC
      - Notes: Partial source reconstruction by community. Rights split between
        Bungie (IP creator, now independent from Microsoft) and Take-Two
        (publisher). Community has maintained mods and patches for 20+ years.
        Rights negotiation complex but community goodwill is strong.

4. REPORT FORMAT (output/source-report.md)
   - Title: "Source Availability Report -- Retro Remake Target List"
   - Date generated
   - Summary table: Name | Year | Rights Holder | Source Status | Community Active?
   - Detailed section per IP with all fields
   - Summary statistics: count by source status, count with active community projects
   - Color-code status in the table using emoji: green circle for official-release,
     yellow circle for decompilation, blue circle for mod-sdk, red circle for nothing

DEPENDENCIES: commander, chalk, cli-table3

💡Copy-paste ready

That entire block is the prompt. The specificity is deliberate — every detail about the database schema, pre-loaded IPs, and report format is there so you get a production-ready research tool on the first try. The pre-loaded data saves you an hour of research you’d otherwise spend confirming who owns what.

What you get

After the AI finishes generating (typically 60-90 seconds), you’ll have this:

source-scanner/
  package.json
  src/
    index.js
    database.js
    report.js
  data/
    source-db.json

Fire it up

cd source-scanner
npm install
node src/index.js list

You should see a formatted table with all 6 IPs, their rights holders, and source status. The red indicators next to BloodRayne and Primal tell the story immediately — clean-room rebuilds, no shortcuts.

Now generate the full report:

node src/index.js report

Open output/source-report.md. You’ll see a professional research document with a summary table, detailed breakdowns for each IP, and statistics. This is the kind of deliverable you’d hand to a business partner or potential investor to show you’ve done your homework.

Try updating a record

Say you find a new community project for BloodRayne:

node src/index.js update "BloodRayne" --notes "Found fan reimplementation discussion on ResetEra, no active project yet"

Run node src/index.js list again — the record is updated with today’s date.

If something is off

Problem	Follow-up prompt
JSON file not found on first run	`The tool can't find data/source-db.json. Make sure index.js resolves the path relative to the project root using path.join(__dirname, '..', 'data', 'source-db.json') and that the file exists after generation.`
Table formatting broken	`The cli-table3 output is misaligned. Make sure each row has the same number of columns as the header and that long text fields are truncated with '...' at 40 characters.`
Add command hangs	`The add command isn't prompting for input. Use readline to create an interactive prompt for each field. Make sure rl.close() is called after the last question.`

Deep dive

Here’s what’s happening inside the tool so you understand the design decisions:

Commander.js routes your commands. list, report, add, update, and search are all subcommands. Each one calls a different function. This is the same pattern used by git (git add, git commit, git log) — familiar structure, easy to extend.
The JSON database is the simplest thing that works. No SQL, no MongoDB, no cloud database. Just a JSON file on disk. For a research database with dozens of entries, this is the right call. You can open it in any text editor, back it up by copying the file, and version-control it with git. When you have 500 IPs and need queries, you upgrade. Not before.
Source status categories are intentionally coarse. Four buckets: official-release, decompilation, mod-sdk, nothing. You don’t need fifteen gradations. You need to know whether you’re building on existing work or starting from zero. That’s the decision that changes your budget by 10x.
The report generator is Markdown, not PDF. Markdown converts to anything — PDF, HTML, Word, a slide deck. Starting with Markdown means you’re not locked into any output format. Paste it into Notion, render it in VS Code, or convert it with pandoc. Your research goes wherever you need it.
Pre-loaded data is the real value. The six IPs in the database aren’t random — they’re curated based on your actual target list. BloodRayne and BloodRayne 2 are your primary targets. The others are comparison cases showing different source-availability scenarios. Legacy of Kain shows what “decompilation exists” looks like. Primal shows the “Sony first-party, good luck” scenario. Darkwatch shows the “rights chain from hell” scenario. Each one teaches you something about the landscape.

🔍Why source availability matters for budget

The difference between “decompilation project exists” and “nothing” is enormous for a remake:

Official source release (id Software’s Quake, Doom): You can study the original implementation, understand the game logic, and potentially fork the codebase. Budget multiplier: 1x (baseline).
Active decompilation (Soul Reaver, Oni): You get a technical reference for how systems worked, but you can’t use the code directly. You still build clean-room, but you have a map. Budget multiplier: ~1.5x.
Mod SDK only (some Bethesda titles): You can study scripting, level formats, and asset pipelines, but core engine code is still closed. Budget multiplier: ~2x.
Nothing (BloodRayne, Primal, Darkwatch): You’re working from the retail game, gameplay videos, and community wikis. Every system must be reverse-engineered by playing. Budget multiplier: ~3-4x.

This is why the scanner exists — it’s the first filter in your business case. An IP with no source material needs a significantly larger budget, and that changes every downstream decision.

Customize it

Your scanner works. Now bolt on features that make it more useful for your actual workflow:

Add a rights-chain visualizer

Add a "chain" command that takes a game name and outputs an ASCII diagram
showing the ownership chain. For BloodRayne: "Terminal Reality (dev, 2002)
-> Majesco (publisher) -> Ziggurat Interactive (acquired June 2020)".
Show each entity, their role, and the transfer date.

Add a community activity checker

Add a --check-activity flag to the report command. For each IP with
community projects, include a note about the last commit date or
activity status. Don't actually hit GitHub's API -- just add a
"lastChecked" field to the schema that you update manually. The report
should flag any community project not checked in the last 30 days.

Add a comparison table

Add a "compare" command that takes 2-3 game names and outputs a
side-by-side comparison table: source status, rights complexity
(simple/moderate/complex), estimated rebuild difficulty, and any
advantages one has over the others. This is the table you'd put in
a pitch deck.

What’s next

You now have a structured database of what source material exists for your target IPs. The picture for BloodRayne is clear: no source, clean-room rebuild, Ziggurat holds the rights. But who exactly is Ziggurat, how did they get the rights, and what does the full ownership chain look like? In the next lesson, you’ll build the BloodRayne Rights Map — a React dashboard showing every entity in the IP ownership chain, the publishing history, and the licensing questions you’ll need answered before you can make a deal.