Necromancer

Cover
01_Home
02
03a
03b
04
05
06
07a
07b

Narrative

This project is intentionally presented as an evolving product built across two hackathons, where each stage adds a complementary capability:

Phase 1 (Kiroween – Resurrection): analyze "dead" codebases and generate structured upgrade rituals.
Phase 2 (FIBO Hackathon): apply the same "ritual + lint + diff" workflow to deterministic JSON-native image generation, adding visual A/B preview.

The result is a consistent philosophy:

take messy, risky inputs (legacy repos / unreviewable prompts)
turn them into structured specs
provide reviewable, explainable patches

Project Story (Phase 1 — Kiroween)

Inspiration

Every developer has inherited a "dead" repository – outdated dependencies, deprecated tooling, and no clear path forward. The typical response is either ignore it and hope nothing breaks, or rewrite everything from scratch.

For Kiroween's Resurrection category, we asked: What if we could summon a necromancer to analyze the decay and plan a structured revival?

Repo Necromancer was born from this spooky idea – combining the Halloween theme with a genuinely useful developer tool.

What it does

Repo Necromancer analyzes legacy repository manifests ([package.json]) and provides:

RotScore (0–100) – A decay rating based on dependency age and risk
Tech Era Detection – Identifies if your repo is from the CRA 2017 era, jQuery legacy, Next.js modern, etc.
Dependency Issues – Per-package analysis with severity levels and explanations
3 Resurrection Rituals:
- 🩹 Quick Patch (2 skulls) – Minimal stabilization
- ⚡ Modern Ritual (3 skulls) – Structured migration
- 🔮 Reincarnation (5 skulls) – Full rewrite guidance

Just paste your manifest, click "Summon Ritual Plan", and get actionable insights in seconds.

How we built it

Framework: Next.js 14 with App Router
Language: TypeScript (strict mode)
Architecture: Layered design – UI → API → Domain (Analyzer + Planner)
Kiro Integration:
- /.kiro/specs/ – YAML schemas for analyzer and planner modules
- /.kiro/steering/ – Architecture and tone guidelines
Styling: Custom dark theme with necromancer aesthetic

The entire project was built using Kiro IDE, leveraging:

Vibe coding for rapid prototyping
Spec-driven development for consistent data models
Steering docs to maintain architectural integrity

Challenges we ran into

Balancing theme vs usability – The necromancer aesthetic needed to be spooky but not obscure functionality
Heuristic accuracy – Creating meaningful RotScore calculations without access to live registry data
Time constraints – Building a complete tool in limited hackathon time while maintaining code quality
Kiro learning curve – Understanding how to best leverage specs and steering for maximum productivity

Accomplishments that we're proud of

End-to-end flow works – Paste manifest → Get analysis → See rituals
Meaningful heuristics – Tech era detection identifies CRA, Next, Angular, Vue, jQuery, Gulp/Grunt
Clean architecture – Pure functions in domain layer, easy to extend
Full Kiro integration – Specs and steering docs that guide development
Preset samples – One-click demos for judges to try instantly

What we learned

Kiro's spec-driven approach accelerates development when you define schemas upfront
Steering docs help maintain consistency across AI-assisted coding sessions
Theme can enhance UX – The necromancer metaphor makes the tool memorable and fun to use
MVP scope discipline matters (ship core first, expand later)

What's next for Necromancer

GitHub Integration
Python support ([requirements.txt])
Export rituals as Markdown
Historical tracking
VS Code extension
Community heuristics

Project Story (Phase 2 — FIBO Hackathon extension)

Inspiration

Prompt engineering is powerful but unreliable: small wording changes can produce unpredictable results, and it is difficult to review or reproduce creative intent at scale.

FIBO flips that model by making image generation JSON-native — camera, lighting, palette, composition become deterministic parameters. We asked: What if we could treat visual generation like software engineering — with validation, diffs, versioning, and reviewable “patches”?

What it does

This is a FIBO JSON Linter + Diff Studio that turns FIBO specs into a production workflow:

Spec Linting – Validate structure and flag risky / inconsistent parameters
Ritual Patches – Apply curated “fix packs”:
- 🩹 Quick Fix – Minimal corrections
- ⚡ Cinematic – Camera + lighting + composition presets
- 🔮 HDR / 16-bit Look – Best-effort look profile (provider dependent)
JSON Diff + Explain – Compare Spec A vs Spec B and summarize changes in plain language
A/B Render Preview – Generate side-by-side images via a provider API to prove the spec diffs are meaningful

How we built it

Foundation: The architecture and UX pattern were carried over from Phase 1 (Next.js 14 + layered domain modules)
Framework: Next.js 14 App Router
Language: TypeScript
Architecture: UI → API → Domain (Linter + RitualPatcher + Diff + Provider)
Provider integration: One initial provider (fal.ai / replicate / bria), configured via env vars

Challenges we expect / need to manage

Provider differences – FIBO endpoints and JSON fields may differ by provider
Schema ambiguity – Public docs may not cover every parameter; we need a safe minimal schema + best-effort lint rules
Keeping it deterministic – Ritual patches must be predictable and explainable
Demo clarity – Show value in <3 minutes: lint → patch → diff → A/B preview

Accomplishments we want to demonstrate in the demo

End-to-end workflow works: paste spec → lint → apply ritual → diff → A/B preview
Diffs are explainable and map to visible changes
The tool makes FIBO controllability understandable for non-experts